- 00:00:09 so let's dive into the most important
- 00:00:12 question what is no t.j.s no js' is a
- 00:00:16 JavaScript runtime and now what does
- 00:00:19 this mean
- 00:00:19 you know JavaScript it's a programming
- 00:00:23 language you typically use in the
- 00:00:25 browser to manipulate your Dom to
- 00:00:29 manipulate the page which was loaded in
- 00:00:31 the browser for example to open a pop-up
- 00:00:34 a modal or add any kinds of effects
- 00:00:37 because javascript is a language to try
- 00:00:39 this in the browser that allows you to
- 00:00:41 interact with the page after it was
- 00:00:43 loaded and therefore a secte rouge apart
- 00:00:46 when it comes to building interactive
- 00:00:48 user interfaces in the browser so
- 00:00:50 whatever your users see however
- 00:00:53 javascript is not limited to that no
- 00:00:56 chess is a different version of
- 00:00:59 JavaScript you could say it is basically
- 00:01:02 built on JavaScript it adds some
- 00:01:05 features to it is not capable of doing
- 00:01:07 some other things you can do with
- 00:01:08 JavaScript in a browser so it basically
- 00:01:10 takes JavaScript and puts it into a
- 00:01:12 different environment it allows you to
- 00:01:15 run JavaScript code on the server you
- 00:01:18 could say in theory not just on the
- 00:01:20 server but on any machine though so it
- 00:01:23 basically allows you to run JavaScript
- 00:01:25 not just in the browser but anywhere
- 00:01:28 else like a normal programming language
- 00:01:30 like normal programs on your computer or
- 00:01:33 some computer in the Internet
- 00:01:35 effectively making it a great choice for
- 00:01:37 building web applications that run on
- 00:01:40 servers which are just computers running
- 00:01:43 somewhere in the internet so in detail
- 00:01:46 this means that we can use nodejs
- 00:01:49 to run JavaScript outside of the browser
- 00:01:52 that is the core takeaway now how does
- 00:01:54 this work technically well no js' uses
- 00:01:58 we ate and we ate simply it's the name
- 00:02:01 off the JavaScript engine built by
- 00:02:04 Google that runs JavaScript in the
- 00:02:08 browser so back to the browser we now
- 00:02:10 are we a to simply the name the
- 00:02:12 creator's gave their engine and what
- 00:02:15 does an engine
- 00:02:16 well it simply means that engine takes
- 00:02:19 javascript code the code running in your
- 00:02:21 browser then or in nodes case which
- 00:02:24 builds up on v8 although the nodejs
- 00:02:26 JavaScript code it takes that JavaScript
- 00:02:29 code and compiles it to machine code and
- 00:02:31 this is what your browser does to what
- 00:02:34 we ate does in your browser it does take
- 00:02:37 your JavaScript code and compile to
- 00:02:39 machine code because dad is the code
- 00:02:41 that runs ultimately on your computer
- 00:02:44 and that can be handled efficiently now
- 00:02:47 this is done by v8 v8 itself is written
- 00:02:51 in C++ but that doesn't really matter
- 00:02:53 too much for you you don't need to write
- 00:02:55 any C++ code to use JavaScript or
- 00:02:58 node.js but no trace basically takes
- 00:03:01 that v8 code bases which is written in
- 00:03:03 C++ and adds certain features like for
- 00:03:07 example working with your local file
- 00:03:09 system opening files reading files
- 00:03:12 deleting files these are all things
- 00:03:14 which are not possible in the browser
- 00:03:16 you can't access your local file system
- 00:03:18 in the browser for security reasons so
- 00:03:20 this is not supported nodejs adds these
- 00:03:23 features to v8 engine you could say so
- 00:03:26 that you can suddenly do that now no
- 00:03:28 chance does not run in the browser so
- 00:03:30 these restrictions still apply there you
- 00:03:33 use vanilla we ate so we ate only
- 00:03:36 without D node.js extensions but if you
- 00:03:39 then install node trace you can use it
- 00:03:42 to basically use that extended v8
- 00:03:44 version to run JavaScript scripts on
- 00:03:48 your computer which then suddenly can
- 00:03:51 access these new features because they
- 00:03:53 don't run in the browser but are
- 00:03:55 directly executed through that no trace
- 00:03:57 runtime you could say so this is how
- 00:04:00 that works together and what noches does
- 00:04:03 it allows you to run JavaScript on your
- 00:04:05 computer and it adds useful
- 00:04:07 functionalities to the JavaScript engine
- 00:04:09 so that you can do more useful stuff
- 00:04:12 there than you can do with browser side
- 00:04:15 JavaScript now one important note maybe
- 00:04:17 on this point all this but of course
- 00:04:19 some features are also taken away in the
- 00:04:22 browser you use JavaScript to interact
- 00:04:24 with the document object model so with
- 00:04:26 the HTML elements on your page if you
- 00:04:29 just executed
- 00:04:30 javascript file directly you of course
- 00:04:32 have no attached page and therefore
- 00:04:34 these features are missing but this is a
- 00:04:37 lot of theory why don't we just have a
- 00:04:40 look at this and see how we can install
- 00:04:43 and use no trace and what it actually
- 00:04:45 does for us let's do that in the next
- 00:04:47 lecture
- 00:04:51 so we want to use nodejs and the first
- 00:04:55 important step is that we install it and
- 00:04:57 for that you have to is it no js' dot or
- 00:05:01 ik there you find an installer in my
- 00:05:04 case here had picked the right one for
- 00:05:06 my operating system Mac OS but you will
- 00:05:09 also find a version for Windows if
- 00:05:11 you're visiting this page on windows or
- 00:05:13 you manually choose a different version
- 00:05:15 and you can of course follow along no
- 00:05:18 matter which operating system you're
- 00:05:20 using the code you write and the steps
- 00:05:22 you need to take to install no chairs
- 00:05:24 are exactly the same you simply download
- 00:05:27 the latest version here and you then
- 00:05:30 simply save it anywhere and run the
- 00:05:33 Installer this gives you now simply
- 00:05:35 follow through all the steps which are
- 00:05:37 mentioned in installer accept the
- 00:05:39 License Agreement and so on so simply
- 00:05:41 click through that install it on your
- 00:05:44 machine and once this completed you
- 00:05:47 already got everything you will need to
- 00:05:49 write nodejs code so this is super fast
- 00:05:52 it's done here you can close this now
- 00:05:54 and now how do we use no chairs well the
- 00:05:59 easiest way of using it is to open up
- 00:06:01 your local terminal or on Windows
- 00:06:04 PowerShell or the command prompt in its
- 00:06:07 terminal as a first step simply run node
- 00:06:11 dash V like this this should show you
- 00:06:15 the version of nodejs you installed now
- 00:06:18 with that being executed you can now use
- 00:06:22 node just like that to enter a special
- 00:06:25 input mode the so-called rebels I'll
- 00:06:28 come back to that where you can execute
- 00:06:30 code and have it parsed by node on the
- 00:06:32 fly you can use this as a calculator
- 00:06:35 simply type two plus two to see the
- 00:06:37 result or you can write whole JavaScript
- 00:06:39 programs there now I won't do that so
- 00:06:42 you can quit it with control C and
- 00:06:44 instead let's write a real script which
- 00:06:47 we can execute with no trace so that we
- 00:06:49 can also see what we can do with it for
- 00:06:51 that create a new folder anywhere on
- 00:06:54 your computer and open that folder in
- 00:06:57 your favorite IDE or code editor now
- 00:07:01 here I am using Visual Studio code you
- 00:07:04 can find that
- 00:07:05 on code dot we'll studio.com this is a
- 00:07:08 great ide which i strongly recommend
- 00:07:10 using it's free it is really built for
- 00:07:13 you such with JavaScript code it will
- 00:07:16 work great and you can simply download
- 00:07:18 it from this page as I said for free
- 00:07:21 simply walk through the installer it's
- 00:07:23 always available for Windows and so on
- 00:07:25 walk through the Installer it gives you
- 00:07:27 and then once it is installed simply
- 00:07:29 start it and open that new folder you
- 00:07:32 created somewhere on your computer
- 00:07:35 this will be your project folder for
- 00:07:37 this very first quick app or script
- 00:07:40 we're going to right now your Visual
- 00:07:42 Studio code might look a bit different
- 00:07:43 I'm in full screen mode which is why you
- 00:07:45 don't see any menu items here at the top
- 00:07:47 and I also got two important things
- 00:07:50 installed here the first one is the
- 00:07:53 theme and you can hit command shift P or
- 00:07:56 ctrl shift P on Windows to go to that
- 00:07:58 quick command interface here and there
- 00:08:01 if you type theme then you can go to the
- 00:08:05 Preferences color theme and choose which
- 00:08:07 theme you want to use and I'm using the
- 00:08:09 dark blaspheme here so if you want to
- 00:08:11 get the exact same coloring you can
- 00:08:12 choose that and I also installed an
- 00:08:15 extension you can view the extension
- 00:08:18 menu by going to view extensions or if
- 00:08:21 you have on the left a menu you can also
- 00:08:25 click on the exchange extensions tab
- 00:08:27 there but view extensions will do or the
- 00:08:29 shortcut you see there and there I
- 00:08:31 installed the material I can theme this
- 00:08:35 theme here I already got that installed
- 00:08:38 and this gives me some special file
- 00:08:39 icons and so on you don't need that you
- 00:08:41 just can use it if you want to have the
- 00:08:43 exact same layout and thereafter you can
- 00:08:45 go back to the view Explorer here now
- 00:08:48 this is then my set up I gotta get
- 00:08:50 ignore file here since I'll use git for
- 00:08:52 a reversion management you don't need
- 00:08:54 that and with that let's simply create a
- 00:08:56 new file here with ctrl + command N or
- 00:08:58 by clicking that icon here and then
- 00:09:01 simply and give it any name you want
- 00:09:02 like first app dot J s dot J ass is of
- 00:09:06 course important because we're creating
- 00:09:07 a JavaScript app here now in there we
- 00:09:11 can run any code nodejs is capable of
- 00:09:14 executing and for this I will write a
- 00:09:17 simple
- 00:09:18 script I will simply write console.log
- 00:09:21 hello from node J s now you could write
- 00:09:25 this in the browser to the browser would
- 00:09:27 be capable of running this and it would
- 00:09:30 lock this and the JavaScript console in
- 00:09:32 your browser dev tools now you can also
- 00:09:34 execute this with no choice though for
- 00:09:36 this go back to your terminal or command
- 00:09:38 prompt and make sure you navigate into
- 00:09:41 that new folder you created with the
- 00:09:44 help of CD and so on you can
- 00:09:47 alternatively also go back to visual
- 00:09:49 studio code and there under view you can
- 00:09:51 open that terminal and that will give
- 00:09:54 you your default system terminal already
- 00:09:57 navigated into that folder so that's a
- 00:09:59 bit more convenient and then here you
- 00:10:01 can run note and now first – fjs so that
- 00:10:06 file name if you now it entered you
- 00:10:09 should see hello from noches here
- 00:10:11 because this execute your code and this
- 00:10:14 already shows you that note is
- 00:10:16 JavaScript on your computer this is not
- 00:10:19 using a browser it's just using the
- 00:10:21 internal engine the extended internal
- 00:10:24 JavaScript engine used by the browser to
- 00:10:27 execute your code locally totally
- 00:10:29 outside of a browser and of course we
- 00:10:32 can also do more than just logging
- 00:10:34 something let's for example write this
- 00:10:37 text to a file for this we can import
- 00:10:41 something from the nodejs environment
- 00:10:44 I mentioned that it would add new
- 00:10:46 features to JavaScript right you have to
- 00:10:48 import them and I'll come back to the
- 00:10:50 detailed import syntax and which
- 00:10:52 features exist a little bit later for
- 00:10:55 now just follow along to have this first
- 00:10:57 quick demo and create a new constant
- 00:11:00 I'll also give you a brief refresher
- 00:11:02 about constants and JavaScript in this
- 00:11:04 course and then type require FS FS
- 00:11:08 stands for file system and this syntax
- 00:11:11 simply imports some file system
- 00:11:14 functionalities into this javascript
- 00:11:16 file so that we can use these
- 00:11:18 functionalities there we can now use FS
- 00:11:22 write file sync here to create a new
- 00:11:26 file and this takes a couple of
- 00:11:28 arguments and the first argument is the
- 00:11:31 path where
- 00:11:32 you want to store that foul and that
- 00:11:34 also includes the filename now once you
- 00:11:36 created in that same folder so I will
- 00:11:38 simply name it hello dot txt for example
- 00:11:41 and the second argument is today that we
- 00:11:43 want to put in there and there I will
- 00:11:45 just put hello from node.js with this if
- 00:11:50 we now save this and we re execute this
- 00:11:53 with node first fjs you should have a
- 00:11:56 hello text file here and this gives you
- 00:11:59 the text written in there and this is
- 00:12:02 something you couldn't do in the browser
- 00:12:04 because there you can't access your
- 00:12:06 local file system and obviously its
- 00:12:08 features like this which you need to
- 00:12:10 then also create a server which we don't
- 00:12:12 have at this point by the way this is
- 00:12:14 not a website obviously it's just some
- 00:12:16 utility script and this is something we
- 00:12:19 can do with nodejs now this was a first
- 00:12:21 quick demo we'll learn all the cool
- 00:12:23 features and how this works and what
- 00:12:26 exactly disks in Texas throughout the
- 00:12:28 course of course
- 00:12:33 so you hopefully got a first picture of
- 00:12:36 what node.js is and why you use it and
- 00:12:39 what you use it for now typically and
- 00:12:41 also what we will do in this course you
- 00:12:43 use node.js to run it on a server to
- 00:12:46 write server-side code and for that we
- 00:12:50 have to have a look at the full picture
- 00:12:51 we have our users using client computer
- 00:12:55 with a browser their mobile phone with a
- 00:12:57 browser even mobile apps and we will
- 00:13:00 come back to how nodejs can communicate
- 00:13:03 with these later in the course too but
- 00:13:05 for now let's stick to the traditional
- 00:13:06 browser picture we get our users using
- 00:13:09 their browser and there we can use HTML
- 00:13:11 CSS and JavaScript javascript in the
- 00:13:14 browser to create web pages right now
- 00:13:18 they wizard a page my page comm and they
- 00:13:21 send the request to do so for example by
- 00:13:23 entering a URL in the browser a request
- 00:13:25 is sent to that URL now there the server
- 00:13:29 comes into play we got our server some
- 00:13:32 computer running in the internet which
- 00:13:33 has the IP associated with that domain
- 00:13:36 which is automatically resolved for us
- 00:13:38 and on that server we then want to
- 00:13:41 execute some code that does something
- 00:13:43 with the incoming requests and returns a
- 00:13:46 response often but not necessarily
- 00:13:49 always as you will learn this response
- 00:13:51 is a HTML page which the browser that in
- 00:13:54 turn can display by the way it is not
- 00:13:57 necessarily just HTML it's all the
- 00:13:59 things like CSS files or JavaScript
- 00:14:01 files with JavaScript code for the
- 00:14:03 browser not for the server now on the
- 00:14:06 server we typically do tasks that we
- 00:14:09 can't or don't want to do from inside
- 00:14:11 the browser for performance or security
- 00:14:13 reasons we connect to databases for
- 00:14:16 example to fetch and store data we do
- 00:14:19 user authentication which we obviously
- 00:14:21 can only do on a place the user can't
- 00:14:23 access to make it more secure and avoid
- 00:14:26 it being hacked we do it for input
- 00:14:29 validation to see if a user enter the
- 00:14:31 correct email address the browser can
- 00:14:33 always be tricked users can even edit
- 00:14:36 their browser source ID code you can
- 00:14:38 open the developer tools and start
- 00:14:39 working on that page you're on but the
- 00:14:42 server is of course sheltered from that
- 00:14:44 the user can't access it
- 00:14:46 and in general we have our business
- 00:14:49 logic on the server
- 00:14:50 everything our user shouldn't see which
- 00:14:53 takes too much time to run in the
- 00:14:54 browser where we obviously want to
- 00:14:56 deliver a fast user experience or
- 00:14:58 anything of that kind and that is where
- 00:15:01 we use nodejs so all the JavaScript code
- 00:15:04 but this time not on the browser but on
- 00:15:06 the server and this is where we use the
- 00:15:09 many features no chess gives us and this
- 00:15:11 is how we indirectly allow our users to
- 00:15:14 work with the server through that
- 00:15:16 request response pattern the direct
- 00:15:19 access is not available so this is how
- 00:15:22 we will use no chess in this course also
- 00:15:24 we will use it to write code on the
- 00:15:27 server that returns data our users our
- 00:15:30 clients can work with now one important
- 00:15:33 side note at this point of time no js'
- 00:15:37 is not limited to running code on a
- 00:15:39 server it's a JavaScript runtime and you
- 00:15:41 even saw a first demo which did not do
- 00:15:44 anything where we needed a browser right
- 00:15:46 we didn't spin up a server there we
- 00:15:49 didn't do anything which we would have
- 00:15:51 reached through a browser will do that a
- 00:15:54 lot throughout the course but we haven't
- 00:15:56 done it thus far because it's just a
- 00:15:58 JavaScript runtime we can execute any
- 00:16:00 JavaScript code with no chairs and often
- 00:16:03 that is code that runs on a server and
- 00:16:05 is executed upon incoming requests but
- 00:16:08 you also often use node.js for average
- 00:16:11 code for example for local utility
- 00:16:14 scripts or Bell tools if you worked with
- 00:16:16 let's say react or angular or view or
- 00:16:19 anything of that kind you actually used
- 00:16:21 note Reyes indirectly a lot for all the
- 00:16:24 build processes these languages or
- 00:16:27 frameworks needed because no task is a
- 00:16:30 great tool for writing utility scripts
- 00:16:33 you have access to the file system so
- 00:16:35 you can write and read and manipulate
- 00:16:37 files and this allows you to do a lot of
- 00:16:39 utilities stuff on your computer that is
- 00:16:41 never exposed to the public and I just
- 00:16:44 want you to know that and I'll even have
- 00:16:46 a section this course where I dive a
- 00:16:48 little bit more in such build tools and
- 00:16:50 non server-side language usages of
- 00:16:53 node.js in general and that is the most
- 00:16:57 popular thing you do with no chest
- 00:16:59 though you
- 00:17:00 in the context of web development and
- 00:17:02 server-side code so you use it to run a
- 00:17:05 server and actually and that is an
- 00:17:06 important difference to PHP for example
- 00:17:09 with nodejs
- 00:17:10 you don't just write the code that is
- 00:17:13 running on your server you also write
- 00:17:16 the server yourself so the code that
- 00:17:19 takes the incoming requests and routes
- 00:17:22 them to your well our code in PHP you
- 00:17:26 have extra tools like Apache or engines
- 00:17:28 which run the servers which listen to
- 00:17:31 incoming requests and then execute your
- 00:17:33 PHP code here noches that's both it does
- 00:17:37 that listening and it then also does
- 00:17:40 whatever you wanna do in your code so
- 00:17:42 that's important and that's something
- 00:17:43 you'll see in action soon we also use it
- 00:17:47 or we therefore also use it to run all
- 00:17:49 our business logic so not just to listen
- 00:17:52 to incoming requests but you then Rick
- 00:17:55 with the requests data work with files
- 00:17:57 work with databases all that fun stuff
- 00:18:00 no trace is capable of and we'll do all
- 00:18:03 that in this course obviously and we
- 00:18:06 also handle the response site not just
- 00:18:08 incoming requests you will also learn
- 00:18:11 how you use no chairs to send back data
- 00:18:13 to your clients be that HTML pages HTML
- 00:18:18 pages with dynamic content or data only
- 00:18:21 in the format of JSON or XML or even
- 00:18:24 files so this is what we use no chance
- 00:18:27 and what we will dive heavily into in
- 00:18:29 this course alternatives to node.js
- 00:18:32 would be things like Python also with
- 00:18:36 frameworks like flask or Django or PHP
- 00:18:39 with frameworks like level maybe or
- 00:18:41 standalone vanilla PHP of course and
- 00:18:43 more asp.net Ruby on Rails all that
- 00:18:47 stuff this basically are all
- 00:18:49 replacements for node.js or no trace can
- 00:18:52 be a replacement for them and there is
- 00:18:54 no clear winner all these languages are
- 00:18:57 capable of doing the same kind of stuff
- 00:18:59 and of course they differ in some
- 00:19:01 technically regards but in general it's
- 00:19:04 great to have that broad variety the
- 00:19:07 huge advantage or one huge advantage of
- 00:19:09 Noches is that it uses JavaScript a
- 00:19:12 language which you need
- 00:19:14 so much in modern web development for
- 00:19:16 all the front-end for some built tools
- 00:19:19 and if you den can also use it on the
- 00:19:21 server side you don't need to learn a
- 00:19:24 bunch of different languages you can use
- 00:19:26 one at the same language and then use
- 00:19:28 that for your server-side code too
- 00:19:30 this is why no J's is a great language
- 00:19:32 to learn you get so much efficiency out
- 00:19:35 of it it's also a highly performant and
- 00:19:37 popular language there are so many jobs
- 00:19:39 out there for no chairs there never was
- 00:19:42 a better time to learn it it's used in
- 00:19:44 so many environments also for a lot of
- 00:19:46 cutting edge stuff but in general no
- 00:19:49 chairs is a great solution it's trending
- 00:19:53 it's fast it's efficient and it makes
- 00:19:56 sure that you only need to learn one
- 00:19:57 language to write all the code you need
- 00:20:00 in a modern web application
- 00:20:06 now that we had a look at the basics
- 00:20:08 about no chairs what we can do with it
- 00:20:10 and now did we even use it let me walk
- 00:20:13 you through the content of this course
- 00:20:14 and explain what's in the course and
- 00:20:17 where you can find what we're almost
- 00:20:20 done getting started in the next module
- 00:20:22 I will give you a brief JavaScript
- 00:20:25 refresher just to make sure we're all on
- 00:20:27 the same page regarding the core
- 00:20:29 JavaScript syntax but more importantly
- 00:20:31 about some next-gen JavaScript features
- 00:20:35 which we'll use in a course basic
- 00:20:37 JavaScript knowledge is assumed and will
- 00:20:39 not be taught in that module but if you
- 00:20:42 just need a refresher some additional
- 00:20:44 information or this next-gen JavaScript
- 00:20:47 knowledge then this is a module you
- 00:20:48 should take otherwise it's optional now
- 00:20:52 after this refresher or immediately
- 00:20:54 after this module if you don't need a
- 00:20:56 refresher we'll dive into the node.js
- 00:20:58 basics how it generally works how we can
- 00:21:01 work with streams of data and some core
- 00:21:04 node.js modules so really the
- 00:21:06 nitty-gritty details you need to know
- 00:21:09 about the the language so to say and
- 00:21:11 we'll then dive into efficiently
- 00:21:14 developing with nodejs how you can debug
- 00:21:18 your code handle errors and so on
- 00:21:21 now thereafter we'll dive into expressjs
- 00:21:24 the most popular framework you can use
- 00:21:27 for no trace I'll explain why we use it
- 00:21:30 and why we still in its heart use nodejs
- 00:21:33 why we still learn about no chest even
- 00:21:36 though we use Express J's because using
- 00:21:39 it makes sense it makes things easier
- 00:21:41 you will use it if you are working with
- 00:21:43 no trace but still of course we still
- 00:21:46 use nodejs
- 00:21:47 with all of that now thereafter we'll
- 00:21:50 dive into templating engines that are
- 00:21:52 basically some tools you could say that
- 00:21:54 allow you to generate HTML pages on the
- 00:21:57 server with dynamic content encoded in
- 00:22:00 them and that is how you can return
- 00:22:02 different pages or pages with different
- 00:22:04 content back to your users so that will
- 00:22:07 be an important module now thereafter
- 00:22:10 we'll dive into the
- 00:22:11 model-view-controller pattern what that
- 00:22:13 is and why we use it and of course how
- 00:22:15 we use it and we'll then have a look at
- 00:22:17 some advanced routing concepts
- 00:22:19 outing is something we'll also learn in
- 00:22:20 the expressjs module and we'll dive
- 00:22:23 deeper into the models of the
- 00:22:25 model-view-controller pattern now after
- 00:22:28 we're done with that it's time to dive
- 00:22:29 into databases and we'll start by
- 00:22:32 connecting our node application with a
- 00:22:34 sequel database my sequel to be precise
- 00:22:37 as a next step we'll dive deeper into
- 00:22:39 that and use a package that makes
- 00:22:41 working with sequel databases easier
- 00:22:43 sequel eyes now in after having seen
- 00:22:46 sequel will continue with no sequel and
- 00:22:50 see how we would use that and we'll use
- 00:22:52 Mongoose there to also make working with
- 00:22:54 that easier and we'll then stick to no
- 00:22:57 sequel for the rest of the course but
- 00:22:59 you'll fully learn both sequel and no
- 00:23:02 sequel now after this we'll dive into
- 00:23:04 sessions and cookies what that is why
- 00:23:07 you use it and how you use it we'll have
- 00:23:09 a look at authentication so how we can
- 00:23:11 make sure that users can sign up and
- 00:23:13 sign in with our application well dive
- 00:23:16 into sending emails how that would work
- 00:23:19 how can we auto generate emails when a
- 00:23:22 user signs up for example we'll also
- 00:23:25 type into advanced authentication
- 00:23:27 features and also authorization which
- 00:23:30 means that for example only a user who
- 00:23:33 created a product can edit or delete it
- 00:23:35 well then have a look at user input
- 00:23:38 validation which is a crucial part in
- 00:23:41 any web application because you want to
- 00:23:43 make sure that the data your users enter
- 00:23:45 into your forms is correct and valid and
- 00:23:48 you'll learn how you can do that
- 00:23:49 efficiently in this module and we'll
- 00:23:52 then dive into error handling because
- 00:23:54 errors will happen for example if the
- 00:23:58 user enters wrong input and I will show
- 00:24:00 you how you can handle different kinds
- 00:24:02 of errors in an elegant way now
- 00:24:05 thereafter we'll dive into something
- 00:24:07 important file up and downloads
- 00:24:10 how can you handle these how can you
- 00:24:12 write code that takes incoming files
- 00:24:15 stores them and is able to return files
- 00:24:18 I'll also show you how you can
- 00:24:20 automatically generate PDF documents on
- 00:24:22 the server in this module well then have
- 00:24:25 a look at pagination so how we can
- 00:24:27 return our data in chunks instead of all
- 00:24:30 the data at once which is not ideal for
- 00:24:33 you
- 00:24:33 our bandwidth will thereafter have a
- 00:24:35 look at a sink request and I'll explain
- 00:24:37 what it is and how we can handle it with
- 00:24:39 no js' and we'll then dive into payments
- 00:24:42 how can we accept payments through a
- 00:24:45 service called stripe Jess obviously
- 00:24:48 something we'll need in any shop we
- 00:24:49 build and thereafter well dive into a
- 00:24:53 different kind of application you can
- 00:24:54 build with no chairs will dive into rest
- 00:24:57 api's and when module does not sound
- 00:25:00 like a lot of content on this very
- 00:25:02 important technology but actually I got
- 00:25:05 two modules on that and we'll also dive
- 00:25:07 into file uploads and rest api's
- 00:25:10 authentication pagination and all that
- 00:25:12 stuff and additionally these modules
- 00:25:15 will build up on the entire modules
- 00:25:17 before that because you will learn the
- 00:25:19 rest API does not differ that much from
- 00:25:22 a normal node application and I will
- 00:25:25 show you in detail which knowledge you
- 00:25:27 still need and how you need to change
- 00:25:29 some things not that many actually to
- 00:25:32 turn an existing application into a REST
- 00:25:35 API now and once we're done with that I
- 00:25:38 will dive into more modern JavaScript
- 00:25:42 feature async/await and how you can use
- 00:25:44 that in your node application and we'll
- 00:25:47 dive into WebSockets and socket IO this
- 00:25:50 is a technology or a set of technologies
- 00:25:52 that allows you to add real time
- 00:25:55 functionalities to your app so for
- 00:25:57 example if one user sends a message and
- 00:26:00 you instantly want to notify another
- 00:26:02 user you can use WebSockets for that and
- 00:26:04 I will show how that works in this
- 00:26:06 module after this module we'll dive into
- 00:26:09 a different kind of api's we had a look
- 00:26:12 at rest api's well then have a look at
- 00:26:14 graph QL api's graph QL is a very modern
- 00:26:17 and popular way of building api's it has
- 00:26:21 some advantages over a REST API also
- 00:26:24 some disadvantages and I will dive into
- 00:26:26 graph QL and how it differs from REST
- 00:26:28 API s in this module and I will show you
- 00:26:31 how to build a graph QL API from scratch
- 00:26:34 with no js' and this will be quite a big
- 00:26:37 module even though it's only one block
- 00:26:39 on this slide
- 00:26:40 now thereafter we'll have a look at
- 00:26:42 deployment how can you take your
- 00:26:45 application you build all your No
- 00:26:47 code you build how can you take that and
- 00:26:49 move it to a real server in the web and
- 00:26:51 ensure that it runs there this will be
- 00:26:53 shown there
- 00:26:54 there are also dive into things like
- 00:26:56 setting up SSL encryption and once we're
- 00:26:59 done with that I'll have a short module
- 00:27:01 on node.js functionalities beyond
- 00:27:04 creating web servers with it because you
- 00:27:06 can use it for our things too as I will
- 00:27:08 mention there and then we're done I'll
- 00:27:11 end the course by giving you some next
- 00:27:13 steps potential ideas on how to continue
- 00:27:15 and by then you will have learned a lot
- 00:27:19 about node.js and Express and the many
- 00:27:23 other things we'll dive into in this
- 00:27:24 course I hope you are as excited as I am
- 00:27:28 and with that let's quickly move on so
- 00:27:30 that we can quickly get to the point
- 00:27:32 where we write code
- 00:27:37 so now that you learned what's inside
- 00:27:39 this course a whole lot as you can see
- 00:27:41 let me explain to you how you can get
- 00:27:44 the most out of this course because this
- 00:27:46 is really important to me I want to make
- 00:27:48 sure that you learn a lot now
- 00:27:50 obviously you want to watch the videos
- 00:27:52 now that seems pretty obvious but this
- 00:27:55 is a video on the montt course watch the
- 00:27:57 videos at your speed this is really
- 00:27:59 important you can use the playback
- 00:28:01 controls here and you Remy to fine tune
- 00:28:03 the speed speed me up if I'm going too
- 00:28:05 slow reduce the speed a bit if I'm going
- 00:28:07 too fast
- 00:28:08 also make sure to occasionally jump back
- 00:28:12 to older sections or videos this is our
- 00:28:15 normal process in learning sometimes you
- 00:28:17 need to reiterate concepts you learned
- 00:28:19 before you want to use that on the Mount
- 00:28:22 nature of the course you don't have to
- 00:28:24 go at the speed I'm going you don't have
- 00:28:27 to go lecture by lecture and then never
- 00:28:29 go back use the tools you got here use
- 00:28:33 the course to its fullest potential and
- 00:28:35 use the on-demand nature in this course
- 00:28:38 we will also build projects and you will
- 00:28:41 find a lot of exercises and assignments
- 00:28:43 I encourage you to do these of course
- 00:28:47 you can also just watch me code and just
- 00:28:49 watch my solutions to the assignments
- 00:28:51 but you will learn way more if you try
- 00:28:53 to solve these things on your own and if
- 00:28:55 you actively code along now one
- 00:28:58 important note for this is of course
- 00:29:00 that you want to do that also at your
- 00:29:03 speed and by well of course all the
- 00:29:06 falling along the videos but also make
- 00:29:09 sure to Google for problems if you hit
- 00:29:12 any not because I don't want to help you
- 00:29:14 I will help you if you need help but
- 00:29:17 because this makes you a better learner
- 00:29:19 you need to be able to solve your
- 00:29:21 problems on your own and I see too many
- 00:29:23 students who have a ask first research
- 00:29:27 later mentality and this is not really
- 00:29:30 that great for you
- 00:29:32 this makes me learn it better because I
- 00:29:34 get challenged a lot which is great but
- 00:29:36 you should learn more
- 00:29:37 ultimately so definitely try to solve
- 00:29:40 your problems on your own it will help
- 00:29:42 you a lot
- 00:29:44 although use all the course resources
- 00:29:47 you find in there that's not just 2
- 00:29:48 videos that's also the attached
- 00:29:50 source code which you find attached to
- 00:29:53 the last lecture of each module which
- 00:29:55 you can use to compare to your code if
- 00:29:57 you're facing any problems and again
- 00:29:59 this is a great way of solving problems
- 00:30:00 on your own
- 00:30:02 by comparing the solutions and finding
- 00:30:04 out what went wrong on your own so use
- 00:30:06 all these resources also make sure to
- 00:30:10 use the additional links I occasionally
- 00:30:12 post in some lectures where you can
- 00:30:14 research a bit more about certain topics
- 00:30:16 and dive a bit deeper in cases where
- 00:30:19 you're interested in that topic now last
- 00:30:22 but not least this course like all udemy
- 00:30:25 courses has a Q&A section you can post
- 00:30:27 questions on every video there's a Q&A
- 00:30:30 button at the bottom of the video or in
- 00:30:32 the course dashboard the general Q&A
- 00:30:34 section and you can search there make
- 00:30:37 sure to also search the Q&A before you
- 00:30:39 post often a question has already been
- 00:30:42 answered but you can also post there if
- 00:30:44 you got a question now the thing about
- 00:30:47 asking is asking is easy answering is
- 00:30:50 hard so try helping others to take this
- 00:30:54 opportunity of answering to questions of
- 00:30:57 other students simply because you again
- 00:31:00 get challenged and if you're wrong that
- 00:31:03 doesn't matter
- 00:31:04 you'll be corrected and you'll learn
- 00:31:05 again but you will learn so much by
- 00:31:08 being forced to think about a problem
- 00:31:10 articulate a solution and the best of
- 00:31:13 all you also help other students so help
- 00:31:15 each other
- 00:31:16 I will also help you of course but if
- 00:31:18 you do all these things you'll get a lot
- 00:31:20 out of this course promised but with
- 00:31:23 dead let's leave this first module and
- 00:31:25 continue with the course
- 00:31:31 now before we finally dive into the
- 00:31:33 JavaScript refresher or optionally
- 00:31:36 incase you skipped that into the node.js
- 00:31:38 basics let me dive into two different
- 00:31:41 ways of executing your node code one way
- 00:31:45 of executing it which I briefly
- 00:31:46 mentioned earlier in this module is the
- 00:31:49 repple rappelled stands for read reading
- 00:31:52 user input evil evaluating user input
- 00:31:56 print outputting a result and l loop for
- 00:32:01 returning and waiting for a new input
- 00:32:03 and the repple is what you use if you
- 00:32:06 just type node into your terminal Here I
- 00:32:10 am in the terminal or on Windows this
- 00:32:12 would be your command prompt and there
- 00:32:13 if you just type node with node
- 00:32:15 installed you are now in the rebel which
- 00:32:17 you can identify by the fact that you
- 00:32:19 now don't have that full path and your
- 00:32:22 computer name at the beginning but just
- 00:32:23 that greater than sign and there you can
- 00:32:27 execute node commands like console.log
- 00:32:30 2+2 or also writing interacting with
- 00:32:34 files you can import the file system
- 00:32:37 there just as we did it previously in
- 00:32:39 our file and then we can use that to
- 00:32:42 write a file synchronously and so on so
- 00:32:45 that will all work here and this is of
- 00:32:48 course an environment where we don't
- 00:32:49 store our code and files but you write
- 00:32:52 our node application with every line the
- 00:32:55 lines don't work independent from each
- 00:32:57 other so I can now use the file system
- 00:33:00 package for example now that I imported
- 00:33:02 it one line earlier but once I quit out
- 00:33:05 of this process with control C I'm done
- 00:33:09 this is not saved anywhere this is not a
- 00:33:11 file I can execute again and this
- 00:33:13 therefore is a great playground the
- 00:33:15 alternative to running codes is that you
- 00:33:17 execute files as we did it before and as
- 00:33:20 we we will basically do it for the rest
- 00:33:22 of this course this is the alternative
- 00:33:23 to using the rebel when you execute
- 00:33:26 files the advantage of course is and
- 00:33:28 that is why we use it for real apps that
- 00:33:30 we write our code in advance and we can
- 00:33:32 always execute it and when we build a
- 00:33:35 real app we want to save our code of
- 00:33:36 course in files which we can then deploy
- 00:33:39 in the end which we could share with our
- 00:33:41 developers and where we can also pause
- 00:33:43 our work
- 00:33:44 pick up later and we're we never lose
- 00:33:46 the code we write but the rattle is a
- 00:33:49 great playground because we can use that
- 00:33:51 to run some commands to try out certain
- 00:33:53 things because we execute code as we
- 00:33:55 write it and therefore these are the two
- 00:33:57 ways of running your node code obviously
- 00:34:01 we'll go with the store code and files
- 00:34:03 approach in this course but whenever I
- 00:34:05 say rebel I'm referring to this direct
- 00:34:08 input way which I can recommend for
- 00:34:11 trying out some features but not for
- 00:34:13 writing real applications that is not
- 00:34:16 what you would do I just wanted to get
- 00:34:18 these two ways out of the way we'll
- 00:34:20 focus on the left one here and with that
- 00:34:22 let's dive into writing some code with
- 00:34:25 the next modules
- 00:34:35 so let's style and what better way to
- 00:34:40 start with it then of course from
- 00:34:42 scratch with its basics in this module
- 00:34:45 you will learn how the web actually
- 00:34:48 works this will only be a brief
- 00:34:50 refresher but since we will of course
- 00:34:52 use nodejs in this course to build a
- 00:34:55 server a web application and write
- 00:34:57 server-side code we obviously have to
- 00:35:00 make sure that we all understand how the
- 00:35:02 web works and which role nodejs plays in
- 00:35:06 that bigger picture now this will only
- 00:35:09 be a brief refresher obviously we'll
- 00:35:11 then dive into creating such a node.js
- 00:35:13 server and running node.js code when
- 00:35:17 requests are reaching that server and of
- 00:35:20 course we'll also send back responses
- 00:35:22 for this will also use node core modules
- 00:35:26 like the filesystem module you saw in
- 00:35:28 the first course section we'll use
- 00:35:31 another very important core module in
- 00:35:33 this section which is related to
- 00:35:36 creating such a web server now as I
- 00:35:38 already mentioned an important part of
- 00:35:40 creating a web server is of course that
- 00:35:43 we're able to handle requests and
- 00:35:45 responses so that you learn how you can
- 00:35:48 use nodejs and the many features it
- 00:35:50 offers to accept incoming requests and
- 00:35:53 do something with them
- 00:35:55 for example parse them and how to send
- 00:35:58 back responses these are crucial things
- 00:36:01 you got to know now related to all of
- 00:36:04 that will learn how nodejs uses
- 00:36:07 asynchronous code and a concept called
- 00:36:09 the event loop to stay reactive and
- 00:36:13 ensure that our script never slows down
- 00:36:16 and always works just fine so with that
- 00:36:20 let's dive into node.js
- 00:36:26 so let me quickly refresh our knowledge
- 00:36:29 on how the web works if you're totally
- 00:36:32 aware of all of this you can of course
- 00:36:33 skip this lecture now the web works like
- 00:36:36 this
- 00:36:36 we got a user a client maybe you sitting
- 00:36:40 in front of your browser visiting a web
- 00:36:42 page we're already being on a web page
- 00:36:44 and submitting a form so you're
- 00:36:46 interacting with web pages let's say you
- 00:36:49 were visiting it so you're entering some
- 00:36:51 URL into your browser and what happens
- 00:36:55 behind the scenes is actually that the
- 00:36:56 browser reaches out to some domain name
- 00:37:00 servers to look that domain up because
- 00:37:02 this domain is not really the address of
- 00:37:05 your server
- 00:37:06 it's basically an encoded human readable
- 00:37:09 version of that address you could say
- 00:37:11 you're a server itself has just an IP
- 00:37:14 address but this is just some technical
- 00:37:16 thing behind the scenes in the end you
- 00:37:18 enter this URL and it will lead to some
- 00:37:21 server you therefore or the browser
- 00:37:23 therefore sends a request to that server
- 00:37:27 with that given IP address I mentioned
- 00:37:30 so the IP address belonging to that
- 00:37:32 domain now that's far that's all
- 00:37:34 interesting but now we reach the part
- 00:37:36 where nodejs comes into play where your
- 00:37:39 Noche s code matters you write the code
- 00:37:43 that runs on that computer in the
- 00:37:45 internet which has that IP address you
- 00:37:48 write the code that spins up that server
- 00:37:51 which is able to handle the incoming
- 00:37:53 request and do something with it now you
- 00:37:55 don't need to use node.js for this you
- 00:37:58 could use PHP as p.net Ruby on Rails
- 00:38:01 anything like that but in this course
- 00:38:03 will obviously use nodejs
- 00:38:05 because well it's a no trace course now
- 00:38:09 in this code you can do all kinds of
- 00:38:11 things and I already mentioned this in
- 00:38:13 the first course module user input
- 00:38:15 validation communicating with the
- 00:38:17 database maybe which runs on a separate
- 00:38:19 database server but which you typically
- 00:38:21 reach out you from your back-end so your
- 00:38:24 server-side code and once you're done
- 00:38:26 with that you do one important thing you
- 00:38:29 send back a response to the client this
- 00:38:33 response can be some HTML text some HTML
- 00:38:36 code which is then handled by the client
- 00:38:39 but it could also be some other kind of
- 00:38:41 data like a file some JSON or XML data
- 00:38:45 the response is more than just a content
- 00:38:48 by the way a response and also request
- 00:38:51 also has headers this is some meta
- 00:38:54 information which is attached to request
- 00:38:56 and response describing what's inside it
- 00:38:58 for example but will see this too so
- 00:39:00 this is how the web generally works and
- 00:39:03 nodejs is the part we will focus on it
- 00:39:06 is the code that makes up that server in
- 00:39:09 the end now that request and response
- 00:39:11 transmission is done through some
- 00:39:14 protocol so basically a standardized way
- 00:39:16 of communicating you could say because
- 00:39:18 obviously to correctly handle a request
- 00:39:22 and send back a response the browser can
- 00:39:25 work with we have to follow some rules
- 00:39:27 and these rules are defined by the
- 00:39:29 protocol we use HTTP or HTTPS HTTP
- 00:39:34 stands for hypertext Transfer Protocol
- 00:39:37 and there we simply define what it is
- 00:39:39 defined how a valid request looks like
- 00:39:42 and how the data should be transferred
- 00:39:44 from browser to server and the other way
- 00:39:46 around
- 00:39:47 an HTTP simply is the same with SSL
- 00:39:50 encryption turned on where all the data
- 00:39:53 that is transmitted is actually
- 00:39:55 encrypted so that if anyone is spoofing
- 00:39:58 your connection they can't read your
- 00:40:01 data now towards the end of the course I
- 00:40:04 will show you how to enable HTTPS for
- 00:40:06 the majority will just use HTTP since
- 00:40:09 will only be developing that code will
- 00:40:12 only work on it locally but once you put
- 00:40:14 it into production I will also show you
- 00:40:17 how to turn on that SSL encryption this
- 00:40:21 is how the web works in a nutshell and
- 00:40:24 how nodejs is related to it and this is
- 00:40:26 exactly where we will now continue
- 00:40:28 working with no chairs and where we will
- 00:40:30 now finally create a server with no
- 00:40:33 chairs
- 00:40:37 I'm back in Visual Studio code D IDE
- 00:40:40 I'll use throughout this course and this
- 00:40:42 is again a totally empty folder I only
- 00:40:44 got my get ignore file in there because
- 00:40:46 I will use version management here get
- 00:40:48 you don't need to use that at all if it
- 00:40:50 doesn't tell you anything you can just
- 00:40:52 ignore that you don't need that git
- 00:40:54 ignore file so I have an empty folder
- 00:40:56 and again I will now create a new file
- 00:40:59 with command and or by pressing this
- 00:41:01 icon here and this file can have any
- 00:41:04 name you want but often you name it
- 00:41:06 server J s or app dot J s because it is
- 00:41:11 the root file that makes up your node.js
- 00:41:14 application so the nodejs code you will
- 00:41:17 execute on a computer in the cloud on a
- 00:41:19 server in the end so I'll name it app J
- 00:41:22 s here now in this file I want to create
- 00:41:25 a server fruit ojs that's far in the
- 00:41:28 first module we only saw how we can work
- 00:41:31 with the file system so how can we now
- 00:41:34 spin out such a server we again need to
- 00:41:37 import some functionality because the
- 00:41:40 way JavaScript works both in the browser
- 00:41:43 and nodejs
- 00:41:44 there is a handful of functions and
- 00:41:48 objects we can use globally without
- 00:41:50 importing anything into that file but
- 00:41:53 generally most functionalities are now
- 00:41:55 available by default to not pollute our
- 00:41:58 global name space with all these
- 00:42:00 reserved key words and names basically
- 00:42:02 and also to make it very obvious in each
- 00:42:04 file on which functionalities this file
- 00:42:07 depends thus far this file does not
- 00:42:09 depend on anything now there are a
- 00:42:12 couple of core modules no treasure ships
- 00:42:15 with and as you will learn from the
- 00:42:16 course you can also install third-party
- 00:42:18 modules which do not ship with node but
- 00:42:21 let's stick to the core modules for now
- 00:42:22 here are a handful of them now not all
- 00:42:25 core modules just some and as you can
- 00:42:28 see there is FS which we already used
- 00:42:30 thus far there also is path which helps
- 00:42:33 us with constructing puffs so paths to
- 00:42:36 files on a file system that work on any
- 00:42:40 operating system because Windows and Mac
- 00:42:43 and Linux use different path formats
- 00:42:45 there is the OS package which helps us
- 00:42:48 with operating system relevant
- 00:42:50 information
- 00:42:51 and so on and there are the two top most
- 00:42:53 packages HTTP and HTTPS and as you might
- 00:42:57 be able to guess these to sound very
- 00:43:00 helpful when it comes to creating a
- 00:43:02 server and working with HTTP requests
- 00:43:04 and HTTP responses and indeed HTTP helps
- 00:43:09 us with launching a server or also with
- 00:43:11 our tests like sending requests because
- 00:43:14 a node app could also send a request to
- 00:43:16 another server you can have multiple
- 00:43:19 servers communicate with each other for
- 00:43:21 example you could send a request to the
- 00:43:23 Google Maps API to send some coordinates
- 00:43:26 and get back an address but that's just
- 00:43:29 an example let's keep it simple here and
- 00:43:31 let's focus on the launch a server
- 00:43:33 aspect HTTP would be helpful when we
- 00:43:36 want to launch an SSL encoded server so
- 00:43:39 where all the data which is transferred
- 00:43:40 is encrypted and as I mentioned earlier
- 00:43:42 this is something I'll come back to
- 00:43:44 towards the end of the course now with
- 00:43:47 that let's use that HTTP module and to
- 00:43:51 use it we need to import it so we
- 00:43:54 basically need to make sure that we can
- 00:43:56 use features from that HTTP module which
- 00:44:00 nodejs ships with but which still is not
- 00:44:03 available globally by default we need to
- 00:44:06 make sure that we can use these features
- 00:44:08 in this file and for this we import that
- 00:44:12 functionality we do this by creating a
- 00:44:15 new constant and you could create a war
- 00:44:18 or use let to but since we'll have some
- 00:44:22 value here which we will never change we
- 00:44:25 can also just use a cons to make this
- 00:44:27 really clear that we will never touch
- 00:44:29 this again we'll use it but will not
- 00:44:31 overwrite it and you can give this any
- 00:44:33 name you want
- 00:44:34 but typically you keep the name of the
- 00:44:37 module you're importing so I'll name
- 00:44:39 this HTTP but again you could rename
- 00:44:41 this to whatever you want then you have
- 00:44:44 an equal sign and now we need to assign
- 00:44:46 a value and now there's a special
- 00:44:48 keyword a special function Noches does
- 00:44:52 expose globally so you can use it by
- 00:44:54 default in any file you run by a note
- 00:44:57 chess and that is the require a keyword
- 00:45:00 now this is simply the way you import
- 00:45:03 files in note
- 00:45:05 yes require ever takes a path to another
- 00:45:09 file you can also import your own
- 00:45:11 JavaScript files but will not do this
- 00:45:14 for now we'll do this heavily throughout
- 00:45:16 the course though or if you don't have a
- 00:45:18 path to one of your files you can also
- 00:45:21 import a core module like HTTP by the
- 00:45:25 way a path to one of your files always
- 00:45:28 has to start with dot slash or slash if
- 00:45:32 it's an absolute path dot slash would be
- 00:45:34 a relative path so this would lead to
- 00:45:36 the same folder and would now look for a
- 00:45:38 HTTP file by the way it automatically
- 00:45:41 adds dot J s at the end you don't need
- 00:45:44 to add it on your own but you can but
- 00:45:46 this would now look for a local file
- 00:45:48 named HTTP if you omit dot slash or
- 00:45:51 slash at the beginning it will not look
- 00:45:54 for a local file so even if you had a
- 00:45:56 file named HD PJs it would not import
- 00:46:00 this file let's get rid of it but
- 00:46:02 instead it will always look for a global
- 00:46:04 module named HTTP and indeed such a
- 00:46:08 module exists because Noches ships with
- 00:46:10 it so now we got this imported and now
- 00:46:14 we can start using functionalities from
- 00:46:16 that global module and you can see that
- 00:46:18 if you type HTTP dot this is how you
- 00:46:22 access functions or so-called methods
- 00:46:25 and properties on objects in JavaScript
- 00:46:28 and as you can see this HTTP object
- 00:46:31 which we import from the HTTP module has
- 00:46:33 a bunch of fields and methods we can
- 00:46:36 execute most importantly it has the
- 00:46:39 create server method now as the name
- 00:46:42 suggests this is a crucial method when
- 00:46:45 it comes to well creating a server and
- 00:46:48 create server actually if we hover over
- 00:46:51 it we can see it actually takes a so
- 00:46:54 called request listener as an argument a
- 00:46:57 request listener simply is a function
- 00:47:00 that will execute for every incoming
- 00:47:03 request so let's define such a function
- 00:47:06 for this I'll create a new function with
- 00:47:09 the function keyword we can name it
- 00:47:12 however you want our queue listener or
- 00:47:14 whatever you want the name is totally up
- 00:47:16 to you and this function
- 00:47:18 has to receive two arguments you can see
- 00:47:21 that here if you hover over that the
- 00:47:23 request listener receives a request
- 00:47:26 which is of type incoming message and a
- 00:47:29 response object so in short Noches
- 00:47:32 automatically gives us some object that
- 00:47:35 represents the incoming request and
- 00:47:37 allows us to read data from that request
- 00:47:39 and it gives us an object response which
- 00:47:43 we can use to return a response to
- 00:47:45 whoever sent that request so now we have
- 00:47:48 to accept these two arguments here and
- 00:47:50 you can again name the arguments however
- 00:47:52 you want you just have to keep in mind
- 00:47:54 that the first one will contain data
- 00:47:56 about two requests and the second one
- 00:47:58 will help you send a response so I'll
- 00:48:01 name it req andres and these are typical
- 00:48:03 shortcuts you often see now this is a
- 00:48:06 function our cue listener and now we
- 00:48:08 can't pass this function reference so we
- 00:48:11 don't execute it don't set these curly
- 00:48:14 braces just pass the name to that
- 00:48:17 function because this will simply tell
- 00:48:19 create server Hey please look for this
- 00:48:22 function with this name and executed for
- 00:48:24 every incoming request so this is now
- 00:48:27 when we set up this function will now
- 00:48:29 run for every request that reaches our
- 00:48:32 server which will be started by calling
- 00:48:35 create server or almost one pieces
- 00:48:38 missing I'll come back to that now this
- 00:48:41 is one way of doing it now you don't
- 00:48:44 have to explicitly create such a
- 00:48:45 function though you can also use a so
- 00:48:48 called anonymous function so here you
- 00:48:51 can also type function req rest like
- 00:48:54 this this is now a function without a
- 00:48:56 name that is why it's called anonymous
- 00:48:58 and it still achieves the same we passed
- 00:49:00 that function to create server and
- 00:49:02 therefore node will execute this
- 00:49:05 function whenever a request reaches our
- 00:49:08 server this is a event-driven
- 00:49:11 architecture nodejs uses heavily you
- 00:49:14 work a lot with such setups or such code
- 00:49:17 snippets where you tell node if X
- 00:49:20 happens do Y so in this case if a
- 00:49:24 request comes please execute this
- 00:49:26 function now you can also use next-gen
- 00:49:30 JavaScript syntax and you
- 00:49:32 Eero function where you omit the
- 00:49:34 function keyword and just have the two
- 00:49:36 arguments followed by an equal sign and
- 00:49:39 a greater sign hence an arrow and then
- 00:49:42 the function body this is basically the
- 00:49:45 equivalent to the function keyword
- 00:49:47 approach okay so this is our create
- 00:49:50 server callback function as it's called
- 00:49:53 it's called by no chairs whenever a
- 00:49:56 request reaches our server for now let's
- 00:49:59 simply console.log the request object to
- 00:50:02 see what's inside now if we execute this
- 00:50:05 file we can do this in the built-in
- 00:50:07 terminal which is already navigated into
- 00:50:09 this project folder make sure you go
- 00:50:12 into that project folder if you're using
- 00:50:14 the terminal outside of that IDE so once
- 00:50:17 you are in a terminal navigated in the
- 00:50:19 folder you can run note and then app J s
- 00:50:22 this will execute the App J's file and
- 00:50:25 let's see what it does
- 00:50:27 hmm nothing right we don't see
- 00:50:29 console.log and that makes sense because
- 00:50:32 we didn't send a request to the server
- 00:50:34 but we don't even know where the server
- 00:50:36 is how do we reach that server which
- 00:50:39 address does it have well one important
- 00:50:42 thing is missing this creates server
- 00:50:45 method actually returns a server so we
- 00:50:49 have to store that in a new variable or
- 00:50:51 constant and I'll use a constant because
- 00:50:53 I'll never overwrite it
- 00:50:55 I only create a server once so now what
- 00:50:57 I created server is stored here and now
- 00:51:00 we can use that server and do something
- 00:51:03 with it as you can see we get a bunch of
- 00:51:05 methods we can call and one important
- 00:51:07 method is listen-listen now actually
- 00:51:10 starts a process where nodejs
- 00:51:13 will not immediately exit our script but
- 00:51:17 where no J's will instead keep this
- 00:51:19 running to listen that's why the method
- 00:51:22 is named like this for incoming requests
- 00:51:25 now listen as you can see it takes a
- 00:51:28 couple of arguments optional arguments
- 00:51:31 the first one is the port on which you
- 00:51:33 want to listen now in production you
- 00:51:35 typically would not fill this out and it
- 00:51:38 would take default of port 80 but here
- 00:51:41 on local development we want to use a
- 00:51:43 different port and you can also define
- 00:51:45 hostname now by default this will be the
- 00:51:48 name of the machine this is running on
- 00:51:50 so for our local machine this is
- 00:51:52 localhost by default so let's just pass
- 00:51:55 a port 3000 is a port you often use but
- 00:51:58 you're relatively free to use any port
- 00:52:01 you want that thousands port are
- 00:52:03 typically pretty safe and now with that
- 00:52:06 if we re execute this you see one
- 00:52:10 important thing the cursor here in the
- 00:52:13 terminal doesn't go back in a new line
- 00:52:15 because this process here is now still
- 00:52:19 running it didn't finish this file
- 00:52:22 execution didn't finish because we now
- 00:52:25 get an ongoing looping process where
- 00:52:28 this will keep on listening for requests
- 00:52:31 and this is obviously what you want
- 00:52:32 right you want to have a web server that
- 00:52:34 keeps on listening for requests now we
- 00:52:38 can see that in action by opening a new
- 00:52:40 browser window where we simply enter
- 00:52:43 localhost 3000 once you did that nothing
- 00:52:48 happens because we haven't configured to
- 00:52:50 return any HTML page but if you go back
- 00:52:53 to your terminal you see a lot of output
- 00:52:56 there and that is this line this is your
- 00:53:01 request being locked to the console now
- 00:53:04 let's analyze what happened here in
- 00:53:06 detail and what's inside this request
- 00:53:09 over the next lectures but these view
- 00:53:12 lines here already give you a fully
- 00:53:15 functional or almost fully functional
- 00:53:17 web server and this is how you create
- 00:53:21 servers in nodejs
- 00:53:23 and I know that this can be hard to wrap
- 00:53:25 your head around because it was for me
- 00:53:28 when I started out with no js' years ago
- 00:53:30 it was difficult to understand that
- 00:53:33 coming from a PHP background you
- 00:53:36 suddenly write your own server that
- 00:53:38 sounded like something super complex
- 00:53:40 well actually it's just these few lines
- 00:53:43 and from now on we just will have to
- 00:53:45 focus on doing something meaningful with
- 00:53:47 the request and important sending back a
- 00:53:51 response so time for detailed analysis
- 00:53:54 in the next lectures
- 00:53:59 in the last lecture we wrote our first
- 00:54:02 little note chess server now this server
- 00:54:05 is not doing all it shipped you it's not
- 00:54:07 returning a response for example but
- 00:54:10 it's generally showing us how we do
- 00:54:12 create through a site code with no chess
- 00:54:15 and how we do create our own servers now
- 00:54:18 let's understand what happened there we
- 00:54:20 executed that file with note app chess
- 00:54:22 because our file was named app jeaious
- 00:54:25 and this essentially started the script
- 00:54:27 where nodejs went fruity and her file
- 00:54:30 parsed the code registered the variables
- 00:54:33 and functions and so on so it basically
- 00:54:35 read our entire code and started
- 00:54:37 executing it but then something
- 00:54:39 important happened we never left that
- 00:54:42 program right the reason for this is an
- 00:54:45 important concept in know chess called
- 00:54:47 the event loop this is basically a loop
- 00:54:50 process which is managed by no trace
- 00:54:53 which keeps on running as long as there
- 00:54:56 is work to do you could say it keeps on
- 00:54:59 running as long as there are event
- 00:55:01 listeners registered and one event
- 00:55:03 listener we did register and we never
- 00:55:05 unregistered is that incoming request
- 00:55:09 listener we passed or we set up with the
- 00:55:12 help of create server we passed a
- 00:55:14 function to create server and that is
- 00:55:16 basically an ongoing event listener when
- 00:55:18 we didn't unregister from and we
- 00:55:21 shouldn't because our server should of
- 00:55:23 course stay up and running so our core
- 00:55:26 node application basically is managed by
- 00:55:29 this event loop all our code is managed
- 00:55:32 by this and as I mentioned note Reyes
- 00:55:34 uses such an event-driven approach for
- 00:55:37 all kinds of stuff not just for managing
- 00:55:39 that server but that is of course a
- 00:55:41 crucial part but you will see it a lot
- 00:55:43 throughout this course for example when
- 00:55:45 we later access a database you will see
- 00:55:47 that there we also basically send that
- 00:55:50 please insert some data request and then
- 00:55:53 we register some function that should be
- 00:55:55 executed once it's done and nodejs uses
- 00:55:59 this pattern because they actually
- 00:56:00 execute single threaded JavaScript so
- 00:56:04 the entire node process basically uses
- 00:56:07 one fret on our computer it's running on
- 00:56:10 now as you might guess if
- 00:56:13 create a server with noches it should of
- 00:56:15 course be able to handle multiple
- 00:56:18 thousands tens of thousands or hundreds
- 00:56:20 of thousands of incoming requests and if
- 00:56:24 it would always pause and then do
- 00:56:26 something with the request this would
- 00:56:28 not be that great
- 00:56:29 hence it uses this event loop concept
- 00:56:31 where in the end it always keeps on
- 00:56:33 running and just executes code when a
- 00:56:37 certain event occurs so that in general
- 00:56:39 it's always available and whilst this
- 00:56:42 might still sound like okay but if I got
- 00:56:44 two incoming requests it needs to handle
- 00:56:46 queue events well it is super fast in
- 00:56:49 handling these requests and actually
- 00:56:52 behind the scenes it does some
- 00:56:54 multi-threading by leveraging the
- 00:56:56 operating system but this event loop is
- 00:56:59 a core thing you have to keep in mind
- 00:57:01 that no js' basically has an ongoing
- 00:57:03 loop as long as there are listeners and
- 00:57:06 create server creates a listener which
- 00:57:08 never stops but if you eventually were
- 00:57:11 to unregister and you can do this with
- 00:57:14 process not exit it would end and we can
- 00:57:17 see that too if we go back to our code
- 00:57:19 and after this line we tie a process dot
- 00:57:24 exit and execute this function and we
- 00:57:27 clear our console and we now repeat no
- 00:57:30 tap J s you see it's now still running
- 00:57:33 because this function never executed we
- 00:57:36 had no incoming request yet but if we
- 00:57:39 now reload this page localhost 3000 you
- 00:57:44 see we still lock that request but then
- 00:57:47 we're back in a new line in the terminal
- 00:57:49 because now it did quit that process it
- 00:57:52 didn't before but now it did it did quit
- 00:57:55 that process with the help of process
- 00:57:58 exit now typically you don't call that
- 00:58:01 in your code because you don't want to
- 00:58:03 quit your server if it quits people will
- 00:58:06 not be able to reach your web page
- 00:58:07 anymore but this is important for
- 00:58:09 understanding how this works process
- 00:58:12 exit basically Hart exited our event
- 00:58:16 loop and therefore the program shuts
- 00:58:18 down because there was no more work to
- 00:58:20 do no TRAI saw that there is no more
- 00:58:22 work to do and it basically closed the
- 00:58:25 program and gave control
- 00:58:27 to our terminal here so this is how we
- 00:58:30 execute such an odious file and how we
- 00:58:33 generally create such a server and what
- 00:58:36 noches does behind the scenes let's see
- 00:58:39 how we can now also work with the
- 00:58:42 requests and with the response object we
- 00:58:45 have in debt anonymous function here
- 00:58:52 so let's go back to the request object
- 00:58:55 relocked here now important just to keep
- 00:58:58 that in mind this request object is the
- 00:59:01 object noches generated for us with all
- 00:59:04 the data off the incoming request when
- 00:59:07 we visited localhost 3000 which we in
- 00:59:10 turn can do because we listen to
- 00:59:12 requests on that port so this is the
- 00:59:15 request object if we have a look at it
- 00:59:18 we see it's a very complex object
- 00:59:21 there's lots of data in it it's not just
- 00:59:23 data these are also partly functions we
- 00:59:26 can call and so on
- 00:59:27 so this is quite a complex object but we
- 00:59:30 also see that for example we have some
- 00:59:33 headers here headers as I mentioned
- 00:59:35 earlier our metadata meta information
- 00:59:37 added to a request and also to responses
- 00:59:41 by the way and there we see for example
- 00:59:43 the host this was sent to the request
- 00:59:46 was sent to you we saw some headers
- 00:59:49 attached by the browser like for example
- 00:59:51 how the response data should be cached
- 00:59:54 and stuff like that which browser we
- 00:59:56 used for that request which kind of
- 00:59:59 response we would accept that we accept
- 01:00:00 some HTML XML and so on that we would
- 01:00:05 accept encoded responses so where the
- 01:00:07 response is actually minified to well
- 01:00:10 safe bandwidth and so on
- 01:00:12 sure all's it was a cookie attached even
- 01:00:14 we have learned about cookies yet we
- 01:00:16 will sell later but this was attached at
- 01:00:18 some Google Analytics cookie we saw
- 01:00:21 which HTTP version was used
- 01:00:25 and so on so there's a lot we can gain
- 01:00:28 from that request but a bit too much now
- 01:00:32 there are only a few important fields
- 01:00:35 you typically need the first important
- 01:00:38 or interesting field is the URL
- 01:00:42 now let's output dad and let's all the
- 01:00:45 output you can output more than one
- 01:00:47 value by separating them with commas
- 01:00:49 request method and all the request
- 01:00:52 headers here
- 01:00:54 let's output these free values and
- 01:00:57 restart the server with node app.js so
- 01:01:00 now it's again listening and let's
- 01:01:02 reload that page on localhost 3000 if we
- 01:01:05 do so now we see the output has changed
- 01:01:08 we still have all the header stuff
- 01:01:10 because we're outputting request headers
- 01:01:12 but prior to that we output the method
- 01:01:15 which you see here it's get and your CD
- 01:01:18 URL and the URL is just a slash here
- 01:01:21 because the URL is basically everything
- 01:01:24 after our host and we just have
- 01:01:27 localhost well nothing and that
- 01:01:30 basically translates to localhost / if I
- 01:01:34 had slash test now we see another output
- 01:01:37 and there we see slash test being locked
- 01:01:41 here and then also get for the method
- 01:01:44 and our headers so this is basically how
- 01:01:47 we can access some information about our
- 01:01:50 request
- 01:01:50 now one crucial thing that is missing
- 01:01:53 here is the response so let's have a
- 01:01:56 look at sending responses in the next
- 01:01:58 lecture
- 01:02:03 in the last lecture you saw how to
- 01:02:05 handle requests and how to read some
- 01:02:07 data from the request like for example
- 01:02:10 the URL and which HTTP method we used
- 01:02:13 now we'll learn about different HTTP
- 01:02:16 methods throughout the course by the way
- 01:02:17 get is to default method used if you
- 01:02:20 just enter a URL into your browser
- 01:02:23 let's now shrink this again let's quit
- 01:02:25 the server you always need to quit and
- 01:02:27 restart if you edit it because otherwise
- 01:02:29 your changes will not be reflected
- 01:02:31 because the old process will still be
- 01:02:33 running and let's now also use that
- 01:02:35 response object now we could lock that
- 01:02:38 with the console but actually this does
- 01:02:40 not hold any interesting data instead we
- 01:02:43 can use it to fill it with data we want
- 01:02:46 to send back we do this by calling rest
- 01:02:49 and now what there are a couple of
- 01:02:53 methods we can use for example set
- 01:02:54 header this allows us to set a new
- 01:02:56 header for example content – type and
- 01:03:01 that is a default header which the
- 01:03:03 browser knows and understands and
- 01:03:04 accepts and then as a second value here
- 01:03:07 as a second argument and set header we
- 01:03:09 set the value for this header key and we
- 01:03:13 can send this to or set this to text
- 01:03:15 HTML now what this will do is it will
- 01:03:17 attach a header to our response where we
- 01:03:21 basically pass a meta information saying
- 01:03:24 that the type of the content which will
- 01:03:27 also be part of the response is HTML now
- 01:03:30 there is of course only a certain set of
- 01:03:32 supported headers the browser
- 01:03:34 understands and after this lecture
- 01:03:36 you'll find an hour later with some link
- 01:03:38 where you can learn which headers you
- 01:03:41 can set now you don't need to set that
- 01:03:44 many let me say that and later we will
- 01:03:46 even learn about a package that does
- 01:03:48 this for us so that we don't have to set
- 01:03:50 the content type on our own but here I
- 01:03:53 will set it now one important thing is
- 01:03:55 missing of course and that is the HTML
- 01:03:58 code right thus far I'm saying we have
- 01:04:00 HTML code but I'm not sending it now we
- 01:04:03 do this by setting response and now we
- 01:04:06 can set right here right allows us to
- 01:04:10 write some data cue the response and
- 01:04:13 this basically works in in chunks you
- 01:04:15 could say
- 01:04:16 were in multiple lines this would be a
- 01:04:18 good picture to look at this you write
- 01:04:21 multiple lines of response for example
- 01:04:23 if we write HTML code like this rests
- 01:04:27 right and if this looks super strange
- 01:04:31 now it is we'll learn about a way easier
- 01:04:33 way of sending HTML later no worries so
- 01:04:36 here I'm just sending HTML and you can
- 01:04:38 also put longer HTML in there of course
- 01:04:41 you could now have your your head where
- 01:04:44 you set title my first page like this
- 01:04:51 and you could put even more into that
- 01:04:54 line but to make it easier to read I'll
- 01:04:56 write a new line where I now have my
- 01:04:59 body is I'm basically writing a whole
- 01:05:02 HTML document here in a very complex way
- 01:05:05 and there I'll just add h1 tag saying
- 01:05:08 hello from my node.js server okay so
- 01:05:13 this is now some HTML code and it will
- 01:05:16 be written to the response line by line
- 01:05:18 we now also need to tell note once we're
- 01:05:21 done with creating that response we do
- 01:05:24 this by calling end so after we set all
- 01:05:27 the headers and wrote all the data to
- 01:05:29 the response body we call end and now
- 01:05:32 it's the point where we must not write
- 01:05:35 anymore we can still call right but this
- 01:05:38 will result in an error because we must
- 01:05:40 not change the response after we ended
- 01:05:43 it because this is basically the part
- 01:05:44 where we will send it back to the client
- 01:05:47 no js' we'll send it back to the client
- 01:05:50 so here it should send back a response
- 01:05:52 with some HTML code inside of it where
- 01:05:56 we also tell the browser that it's HTML
- 01:05:58 code the browser wouldn't know otherwise
- 01:06:00 and with that if we save that file make
- 01:06:04 sure you never forget to save your
- 01:06:06 changes and weary execute it we again
- 01:06:09 have that running process and now if I
- 01:06:13 reload my localhost 3,000 page here we
- 01:06:17 see hello from my noches server and if I
- 01:06:20 open the chrome developer tools here
- 01:06:22 which you can also do from the menu I
- 01:06:25 use the shortcut you can also use view
- 01:06:29 developer div
- 01:06:30 / tools or that shortcut you see here
- 01:06:32 now if you do that let me reload in the
- 01:06:36 network tab here you will see this
- 01:06:39 request this first request and there you
- 01:06:42 see headers like for example in response
- 01:06:45 headers there you see my content type
- 01:06:48 which I said right this is the header we
- 01:06:51 set here and if we click on response
- 01:06:55 itself to see the response body we see
- 01:06:58 that HTML document code we wrote with
- 01:07:00 the head section with my first page and
- 01:07:03 so on so this is now how we can send a
- 01:07:07 response will later also learn about a
- 01:07:11 way simpler way of doing that by using
- 01:07:13 the Express J's framework but it's super
- 01:07:16 important that you understand all the
- 01:07:18 nitty-gritty details that go on behind
- 01:07:21 the scenes and in this case we simply
- 01:07:23 understand it by writing all the
- 01:07:25 nitty-gritty code on our own this is how
- 01:07:27 we can work with requests and send
- 01:07:30 responses now let's connect both the
- 01:07:32 request data we can get and the response
- 01:07:35 data we can send
- 01:07:40 in the last lectures we learned how to
- 01:07:42 spin up that server and that we got a
- 01:07:45 request object with information about
- 01:07:47 the incoming requests and the response
- 01:07:49 object that we can use to send back a
- 01:07:51 response let's now connect both requests
- 01:07:54 and response instead of printing some
- 01:07:56 request data to the console which of
- 01:07:58 course doesn't do much for us let's
- 01:08:00 instead start writing a very simple web
- 01:08:03 server that does different things
- 01:08:05 depending on which route we enter so
- 01:08:08 depending on which slash whatever part
- 01:08:10 we enter here so let's say for slash
- 01:08:14 nothing we want to load a page where the
- 01:08:17 user can enter some data which we then
- 01:08:21 store in a file on the server once it is
- 01:08:24 sent we can do this by first of all
- 01:08:28 parsing the URL I'm storing it in a new
- 01:08:32 constant and I do this by accessing
- 01:08:35 request URL remember that was something
- 01:08:38 like slash slash test whatever we
- 01:08:40 entered
- 01:08:41 I will then add an if statement and
- 01:08:43 check if URL is equal to just slash and
- 01:08:47 only this will match by the way the
- 01:08:50 triple equal sign means that this will
- 01:08:51 only be true if URL is both a string and
- 01:08:55 has that value so now here if that is
- 01:09:01 the case I want to return a response
- 01:09:03 which holds some HTML that gives the
- 01:09:06 user an input form and a button that
- 01:09:09 will send a new request in return and
- 01:09:11 that will not be a get request by the
- 01:09:14 way so let's see that step by step let's
- 01:09:16 copy this code here and put it into this
- 01:09:20 if statement and here I will write a
- 01:09:23 HTML document with a head maybe a
- 01:09:26 different title enter message and the
- 01:09:30 body will now not hold a h1 tag but
- 01:09:34 instead a form this is a default HTML
- 01:09:38 element of course with a input of type
- 01:09:41 text let's say and a button and this
- 01:09:46 will be super ugly because we have no
- 01:09:48 styling but it's about the functionality
- 01:09:50 for now the button tag must be closed by
- 01:09:53 the way
- 01:09:54 the button will be of type submit' so
- 01:09:57 that it submits the form and that will
- 01:09:59 be some default HTML behavior we were
- 01:10:01 using here where a button with type
- 01:10:03 submit' in a form element will send a
- 01:10:06 new request and we'll configure that
- 01:10:08 request in a second let's first give the
- 01:10:11 button a caption send and now on that
- 01:10:14 form element here we add a action which
- 01:10:17 is basically the URL this request which
- 01:10:20 will be generated automatically should
- 01:10:22 be sent to and I will use slash message
- 01:10:26 here and this will automatically target
- 01:10:29 the host it's running on so localhost in
- 01:10:31 our case here localhost 3000 to be
- 01:10:34 precise and then we define the method
- 01:10:37 the HTTP method that should be used and
- 01:10:39 there we previously saw if we expand
- 01:10:43 this that we got a get request which is
- 01:10:45 the default if we enter a URL well here
- 01:10:48 we're not entering a URL instead we want
- 01:10:51 to send a so called post request there
- 01:10:54 is a limited set of HTTP words which you
- 01:10:57 can use get and post are the two most
- 01:11:00 important ones a get request is
- 01:11:03 automatically sent when you click a link
- 01:11:05 or enter a URL a post request has to be
- 01:11:09 set up by you by creating such a form
- 01:11:11 there also are some other ways by using
- 01:11:14 JavaScript but we'll ignore them for now
- 01:11:16 so in HTML we create such a form and we
- 01:11:19 define that the method should be post
- 01:11:20 and this will send a post request to
- 01:11:23 slash message and the cool thing about
- 01:11:25 form is it will not just send such a
- 01:11:27 request it will also look into the form
- 01:11:30 detect any inputs or related elements
- 01:11:34 like selects we might have and if we
- 01:11:37 give that input a name which we should
- 01:11:39 message it will also automatically put
- 01:11:43 that message into the request it sends
- 01:11:46 to our server so now here when we wizard
- 01:11:50 just localhost 3000 slash nothing we
- 01:11:54 will return a response where we render
- 01:11:56 this HTML code now let's also put a
- 01:12:00 return statement in front of res end
- 01:12:02 this is not required to return a
- 01:12:05 response but to return
- 01:12:08 from this anonymous function and to not
- 01:12:10 continue this code because we returned
- 01:12:12 prior to it and this will quit the
- 01:12:15 function execution and we must do this
- 01:12:17 because I told you that after rest end
- 01:12:19 we must not call any other rest riots or
- 01:12:23 arrests set headers but this would
- 01:12:25 happen if we not return because then it
- 01:12:28 would just continue execution with these
- 01:12:29 lines I don't want that if we make it
- 01:12:32 into the if statement we should also
- 01:12:34 quit here we should exit out of this
- 01:12:36 function with this let's restart the
- 01:12:39 server by quitting it with ctrl C and
- 01:12:42 restarting it with node API ass and
- 01:12:45 let's reload this page on localhost 3000
- 01:12:49 slash nothing and we see my input and
- 01:12:54 the send button here again not super
- 01:12:58 pretty but it's working now let's make
- 01:13:01 sure that if we enter something we had
- 01:13:03 sent we see this that we now not only
- 01:13:07 see this but that something else happens
- 01:13:09 by the way we do see this because now
- 01:13:12 the URL is slash message and slash
- 01:13:16 message does not make it into the safe
- 01:13:18 statement and therefore disk code runs
- 01:13:20 but we want to do something else so
- 01:13:22 let's do that in the next lectures
- 01:13:28 so we made sure that we listened to
- 01:13:31 requests to just slash nothing and that
- 01:13:34 we returned some HTML code with our
- 01:13:36 input field on it now when we click that
- 01:13:39 send button we send a post request to
- 01:13:41 slash message but we're not doing
- 01:13:43 anything with that time to change that
- 01:13:45 let's add an average statement here and
- 01:13:48 let's check if the URL is equal to
- 01:13:51 message and let's add an average
- 01:13:53 condition and that condition is that I
- 01:13:55 want to be sure that we're not handling
- 01:13:58 a get request at a post request here so
- 01:14:01 let's also parse the method from request
- 01:14:05 method and make sure that method is
- 01:14:09 equal to post now we'll only enter this
- 01:14:13 if statement if we have a post request
- 01:14:15 to slash message which happens to be
- 01:14:18 exactly what we create with this form in
- 01:14:20 this case I want to do two things
- 01:14:24 I wanna redirect the user back to slash
- 01:14:30 nothing so not leave him on slash
- 01:14:32 message and I want to create a new file
- 01:14:36 and stored a message to user entered in
- 01:14:39 it now this involves a couple of things
- 01:14:42 let's start with redirecting and
- 01:14:44 creating that file we actually already
- 01:14:47 worked with a file in the first course
- 01:14:49 section and do you remember how dad
- 01:14:52 worked
- 01:14:53 feel free to go along on your own if you
- 01:14:56 know that we need another package
- 01:15:00 another core module and that was the
- 01:15:03 file system core module so let's import
- 01:15:06 it by storing the functionality in a
- 01:15:08 constant you can name it however you
- 01:15:10 want I'll name it FS because the package
- 01:15:13 has named FS but you can also name this
- 01:15:15 differently at this not the package just
- 01:15:18 a constant so FS allows us to work with
- 01:15:22 the file system and here I now want to
- 01:15:25 write a new file so here let's execute
- 01:15:28 write file and write file takes a path
- 01:15:32 to the file and I'll just use the
- 01:15:34 filename to create it in the same folder
- 01:15:36 as fjs and i'll simply name it message
- 01:15:40 dot txt
- 01:15:41 and in there I obviously want to store
- 01:15:44 what the user sent now this is a little
- 01:15:45 bit more work so for now let's just put
- 01:15:48 some dummy text in there and let's
- 01:15:50 redirect the user now important we
- 01:15:53 should actually use write file sync for
- 01:15:56 now and I'll explain what the difference
- 01:15:57 to write file which also exists is in a
- 01:16:01 while so let's use write file sync for
- 01:16:03 now now right head which basically
- 01:16:07 allows us to write some meta information
- 01:16:10 in one go and then we set a status code
- 01:16:13 of 302 which stands for redirection and
- 01:16:16 then we've has a JavaScript object with
- 01:16:19 some headers we want to set and you
- 01:16:21 could also do this in two steps by the
- 01:16:22 way you can also set the status code to
- 01:16:26 two 302 and then simply have loops set
- 01:16:30 header and there we set the location
- 01:16:33 this is also a default header accepted
- 01:16:36 by the browser and we set that location
- 01:16:38 to just slash and it will automatically
- 01:16:40 use the host we're already running on
- 01:16:42 and then we have to call rest and and
- 01:16:45 important as before return this so that
- 01:16:49 we don't execute these lines otherwise
- 01:16:51 we'll get an error
- 01:16:53 now let's restart our file here and make
- 01:16:58 sure to go back to slash nothing and
- 01:17:01 reload that page with the input field
- 01:17:03 and send any value and you should simply
- 01:17:06 reload that in the end because you get
- 01:17:08 redirected here but you can see that
- 01:17:10 redirect here in the network tab of the
- 01:17:12 developer tools here 302 indicates we
- 01:17:15 send a request to message and we were
- 01:17:17 redirected to localhost so this is
- 01:17:20 working and we also get the message text
- 01:17:22 with dummy inside of it now let's also
- 01:17:25 get rid of that though and let's work on
- 01:17:30 actually parsing the data the user sent
- 01:17:32 us and writing dead data into that file
- 01:17:39 so time to parse the incoming requests
- 01:17:42 and gets the data that is part of the
- 01:17:45 request because that data should be
- 01:17:47 whatever we entered here now how do we
- 01:17:50 get access to that well we got request
- 01:17:53 URL and request method you might think
- 01:17:56 there is something like request data but
- 01:17:59 there isn't
- 01:18:00 instead the incoming data is basically
- 01:18:03 sent as a stream of data and there is a
- 01:18:06 special construct javascript in general
- 01:18:09 knows but no js' uses a lot now what is
- 01:18:12 such a stream of data though there is a
- 01:18:15 connected concept buffers and we'll have
- 01:18:17 a look at both here so let's take our
- 01:18:20 incoming request as an example there
- 01:18:22 also are other streams like for example
- 01:18:24 when working with files we can also work
- 01:18:26 with streams but let's stick to requests
- 01:18:28 here our stream here is basically an
- 01:18:31 ongoing process the request is simply
- 01:18:34 read by note in chunks you could say in
- 01:18:38 multiple parts and in the ends at some
- 01:18:41 point of time it's done and this is done
- 01:18:43 so that we theoretically can start
- 01:18:46 working on this on the individual chunks
- 01:18:48 without having to wait for the full
- 01:18:50 request being read now for a simple
- 01:18:53 request like the one we're working with
- 01:18:55 this is not really required we only got
- 01:18:58 one input field data it doesn't take so
- 01:19:01 long to parse that but consider a file
- 01:19:04 being uploaded this will take
- 01:19:06 considerably longer and therefore
- 01:19:08 streaming that data could make sense
- 01:19:11 because it could allow you to start
- 01:19:13 writing this to your disk so to your
- 01:19:16 hard drive where your app runs your note
- 01:19:19 app runs on your server was the data is
- 01:19:22 coming in so that you don't have to
- 01:19:24 parse the entire file which is of course
- 01:19:27 taking some time and you have to wait
- 01:19:29 for it being fully uploaded before you
- 01:19:31 can do anything with it but this is how
- 01:19:33 node handles all requests because it
- 01:19:36 doesn't know in advance how complex and
- 01:19:38 big they are so you can start working on
- 01:19:42 the data earlier the problem is with
- 01:19:44 your code you can't arbitrarily try to
- 01:19:47 work with these chunks instead
- 01:19:51 you organize these incoming chunks you
- 01:19:54 use a so called buffer a buffer is like
- 01:19:57 a bus stop if you consider buses they're
- 01:20:00 always driving but for users or
- 01:20:04 customers being able to work with them
- 01:20:06 to climb on the bus and leave the bus
- 01:20:09 you need bus stops where you well you
- 01:20:12 can interact with the bus basically and
- 01:20:14 that is what a buffer is a buffer is
- 01:20:16 simply a construct which allows you to
- 01:20:19 hold multiple chunks and work with them
- 01:20:23 before they are released once you're
- 01:20:25 done and you work with that buffer now
- 01:20:29 that's pretty abstract but it's pretty
- 01:20:30 easy to work with fortunately so let's
- 01:20:33 see how it works in practice when
- 01:20:35 receiving a posted message before
- 01:20:37 sending the response and before writing
- 01:20:40 to the file we want to get our request
- 01:20:42 data right and we do this by going to
- 01:20:45 our request and registering an event
- 01:20:49 listener we haven't done that thus far
- 01:20:52 but as I mentioned know'd uses these
- 01:20:54 heavily for a create server it
- 01:20:56 implicitly creates one for us now we do
- 01:20:59 this on our own
- 01:21:00 by using the on method now on allows us
- 01:21:04 to listen to certain events and the
- 01:21:07 event I want to listen to here is the
- 01:21:09 data event you see my IDE even gives me
- 01:21:12 some help here and tells me which events
- 01:21:14 I can listen to for a request so here I
- 01:21:17 want to listen for the data event the
- 01:21:20 data event will be fired whenever a new
- 01:21:23 chunk is ready to be read you remember
- 01:21:26 that buffer thing this is basically
- 01:21:28 helping us with that now here we have to
- 01:21:33 add a second argument which is that
- 01:21:34 function that should be executed for
- 01:21:37 every data event you remember a create
- 01:21:39 server it has a similar concept there we
- 01:21:42 define a function that should be
- 01:21:43 executed for every incoming request now
- 01:21:46 we're defining a function to be executed
- 01:21:48 for every incoming data piece so here
- 01:21:51 I'll again use a es6 arrow function you
- 01:21:54 could always use the function keyword
- 01:21:56 without that arrow then and as you can
- 01:21:59 also see on data this listener receives
- 01:22:03 a chance
- 01:22:04 of data so here we receive a chunk and
- 01:22:07 this chunk is something we can work with
- 01:22:10 here and now we have to do something
- 01:22:12 with this chunk to be able to interact
- 01:22:14 with it for this I will create a new
- 01:22:18 constant here and I'll name it body
- 01:22:22 because I'll try to read the request
- 01:22:24 body you can name it however you want
- 01:22:26 but it is to request body we're working
- 01:22:29 with now the body should be an empty
- 01:22:32 array and now in that function here in
- 01:22:36 the data event I'll take my body and
- 01:22:38 push a new element onto it by the way if
- 01:22:42 you're wondering how we can edit a
- 01:22:44 constant value this only means that we
- 01:22:47 can never really value so we can never
- 01:22:51 use body equals something again but with
- 01:22:54 push we're changing the object behind
- 01:22:57 that body element that body object we're
- 01:23:01 editing the data in that object not the
- 01:23:04 value itself not the object itself it's
- 01:23:07 a bit strange to wrap your head around
- 01:23:08 but this is in the end how it works so
- 01:23:11 we can now push a new element into this
- 01:23:14 array to make it non-empty and we push
- 01:23:16 our chunk here now nodejs will execute
- 01:23:20 this so often until it's done getting
- 01:23:22 all the data out of our request that can
- 01:23:24 be ones that can be multiple times and
- 01:23:27 we can even lock this to see how how
- 01:23:29 often it does this and what's inside of
- 01:23:31 this chunk now we need to register an
- 01:23:35 aviary event listener and that is d and
- 01:23:37 listener this will be fired once it's
- 01:23:40 done parsing the incoming request data
- 01:23:42 or the incoming requests in general here
- 01:23:45 it will again execute a function we
- 01:23:47 define as a second argument and in this
- 01:23:50 function we can now rely on all the
- 01:23:53 chunks being read in and they're all
- 01:23:55 stored in the body now now to interact
- 01:23:59 with this and don't forget to come after
- 01:24:02 end to interact with that to work with
- 01:24:06 all these chunks we now need to buffer
- 01:24:09 them remember that bus stop concept we
- 01:24:12 got all these chunks we now need to do
- 01:24:14 something to be able to work with them
- 01:24:16 to basically have one
- 01:24:18 the bus stops and we can interact with
- 01:24:21 it so here I'll now create a new
- 01:24:24 constant parsed body and there I will
- 01:24:28 use the buffer object which is available
- 01:24:30 globally made available by nodejs and I
- 01:24:34 can concat my body so this will in the
- 01:24:38 end create a new buffer and add all the
- 01:24:40 chunks from inside my body to it and
- 01:24:42 then on this buffer which I got here
- 01:24:45 parsed body is now a buffer there I can
- 01:24:49 call to string to convert it to a string
- 01:24:52 so this is a utility method offered by
- 01:24:54 nodejs
- 01:24:54 where we do something to our buffered
- 01:24:57 chunks remember the bus is now waiting
- 01:25:00 and the bus stops so to say the buffer
- 01:25:03 is our bus stop and now we do something
- 01:25:05 with it
- 01:25:06 here we convert it to a string and this
- 01:25:08 only works because I know that the
- 01:25:10 incoming data will be text because the
- 01:25:13 body of that request will be text if it
- 01:25:16 were a file we would have to do
- 01:25:18 something different but it is no file
- 01:25:20 and I know that it isn't because we're
- 01:25:22 writing the code we know what we will
- 01:25:24 receive right so this is the parsed body
- 01:25:26 and this is now finally when we can work
- 01:25:30 with so let's also output the parsed
- 01:25:33 body this was a lot of talking so let's
- 01:25:36 simply have a look with the server with
- 01:25:38 control C and restart it and then send
- 01:25:43 another request with some message here
- 01:25:45 and now if you have a look at what's
- 01:25:48 being locked you see two elements the
- 01:25:50 first one is coming from this console
- 01:25:52 log and you see that is a chunk that is
- 01:25:55 a chunk we can't work with but now the
- 01:25:57 parse body really sees or yields this
- 01:26:01 line and that is something we can work
- 01:26:03 with and it's message equals something
- 01:26:05 because we named our input here message
- 01:26:10 and as I said that forum will
- 01:26:12 automatically send a request where it
- 01:26:14 takes all the input data and puts it
- 01:26:16 into a request body as key value pairs
- 01:26:20 where the names assigned to the inputs
- 01:26:22 are the keys and the values are what the
- 01:26:24 user entered and that is what we have
- 01:26:26 here a key value pair separating the key
- 01:26:30 from the value with an equal
- 01:26:31 sign now and with that we can now work
- 01:26:35 with that and finally store the input in
- 01:26:39 our file and we can do that here and
- 01:26:43 request on and request on and to be
- 01:26:45 precise by creating a new constant
- 01:26:48 message taking the parsed body and
- 01:26:52 splitting it on the equal sign and then
- 01:26:55 taking the element with the index one
- 01:26:57 which is the second element in the
- 01:26:59 resulting array which is the element on
- 01:27:01 the right of the equal sign and now we
- 01:27:03 can move right file sync into the end
- 01:27:06 function we don't want to execute it
- 01:27:09 here because this will actually run
- 01:27:11 before this function is called because
- 01:27:14 here we just register a function to be
- 01:27:16 called in the future it's not executed
- 01:27:19 immediately
- 01:27:19 remember note doesn't wait and pause it
- 01:27:22 will not block the script execution it
- 01:27:25 just registers this as a to be executed
- 01:27:28 action and then right away continues so
- 01:27:31 if we have something that depends on the
- 01:27:33 incoming data we have to move it into
- 01:27:35 the event listener to so that it's all
- 01:27:38 the part of the to be executed code
- 01:27:40 sometimes in the future and doesn't run
- 01:27:42 too early and now we can write message
- 01:27:47 to the message to text file
- 01:27:49 let's now restart this file one more
- 01:27:51 time and enter hello here and hit send
- 01:28:00 and now if you look into message text we
- 01:28:03 see hello you see the exclamation mark
- 01:28:05 was encoded now that is something we can
- 01:28:08 worry about later but in general this
- 01:28:10 worked just fine and if you are now
- 01:28:13 totally frightened by how complex nodejs
- 01:28:17 is this is the raw logic will later use
- 01:28:20 Express J's which hides all that raw
- 01:28:23 logic but to understand why we use that
- 01:28:26 you first of all need to understand what
- 01:28:28 is happening and why using tools like
- 01:28:31 expressed chess which will make all of
- 01:28:33 this much easier are great so with that
- 01:28:37 we got our basic logic down let's now
- 01:28:40 dive again into that event listener and
- 01:28:43 writing files thing
- 01:28:45 because there is something really
- 01:28:46 important you have to understand
- 01:28:52 we already achieved a lot in this
- 01:28:54 section and I know that all this code
- 01:28:57 looks kind of intimidating and no
- 01:29:00 worries it will become much easier but I
- 01:29:03 find it super important to learn it the
- 01:29:05 hard way first so that you never forget
- 01:29:07 what's happening behind the scenes
- 01:29:10 now one crucial thing which I know that
- 01:29:13 people often struggle with is that the
- 01:29:16 order of execution of your code here is
- 01:29:19 not necessarily the order in which you
- 01:29:22 write it for example this here will
- 01:29:26 actually execute after this code so it
- 01:29:29 will even execute after we already sent
- 01:29:32 a response this has two important
- 01:29:34 implications for one sending the
- 01:29:37 response does not mean that our event
- 01:29:40 listeners here are dead they will still
- 01:29:42 execute even if the response is already
- 01:29:44 gone but it also means that if we do
- 01:29:47 something in the event listener that
- 01:29:49 should influence in the response this is
- 01:29:51 the wrong way of setting it up we should
- 01:29:53 then also move the response code into
- 01:29:55 the event listener if we had such a
- 01:29:57 dependency but it also means that it's
- 01:30:00 super important to understand that with
- 01:30:03 requests on or code like HTTP create
- 01:30:07 server these are some examples where
- 01:30:10 nodejs uses a pattern where you pass a
- 01:30:13 function to a function and node will
- 01:30:16 execute these passed in functions at a
- 01:30:19 later point of time which is called
- 01:30:22 asynchronously now it's not always the
- 01:30:24 case that a passed in function is
- 01:30:26 necessarily executed at a later point of
- 01:30:29 time but no js' used this pattern
- 01:30:31 heavily and throughout the course I'll
- 01:30:33 of course let you know when this is the
- 01:30:35 case and when node execute something
- 01:30:37 asynchronously in such cases no chairs
- 01:30:43 won't immediately run that function
- 01:30:46 instead what it does when it first
- 01:30:48 encounters this line is it will simply
- 01:30:51 add a new event listener internally it
- 01:30:54 manages all these listeners internally
- 01:30:56 in this case for the end event on the
- 01:31:00 request which will be triggered
- 01:31:01 automatically once nodejs is done
- 01:31:03 parsing the request so this
- 01:31:05 something noches does for you and it
- 01:31:08 will then call that function for you
- 01:31:11 once it is done so in the end you can
- 01:31:13 think of this like nodejs having some
- 01:31:16 internal registry of events and
- 01:31:19 listeners to these events and a function
- 01:31:21 like this is such a listener and when
- 01:31:24 sort of something happens so when nodejs
- 01:31:26 is done parsing your request it will go
- 01:31:29 through that registry and see hmm
- 01:31:32 I'm done with the request so I should
- 01:31:34 now send the end event so let's see
- 01:31:36 which listeners I have for that and it
- 01:31:39 will then find this function and any
- 01:31:42 other functions you might have
- 01:31:43 registered for that and will now call
- 01:31:45 them but it will not pause the average
- 01:31:49 code execution and that is so important
- 01:31:51 to understand so for example here now
- 01:31:54 since I moved return response and into
- 01:31:57 this function the flow is like this it
- 01:32:00 will now reach this if statement and if
- 01:32:03 these conditions are met it will go
- 01:32:04 inside of it it will then register these
- 01:32:08 two handlers and not immediately execute
- 01:32:10 these two functions instead the
- 01:32:12 functions are just registered internally
- 01:32:15 in its event emitter registry and then
- 01:32:18 it will jump straight away to the next
- 01:32:20 line and therefore right now if I would
- 01:32:24 restart my server save the code and
- 01:32:26 restart my server here you will see that
- 01:32:29 if I enter something here I actually get
- 01:32:32 redirected to dispatch or not even
- 01:32:34 redirected as you can see there is no
- 01:32:36 300 status code instead it just loads
- 01:32:39 this page because it executes these
- 01:32:42 lines because as a now mentioned
- 01:32:44 multiple times it will not execute this
- 01:32:46 right away and this return statement
- 01:32:48 will therefore not quit this overarching
- 01:32:51 function here instead it just registers
- 01:32:55 this callback and immediately moves on
- 01:32:57 to the next lines and it would
- 01:32:59 eventually execute this line but that is
- 01:33:01 already too late which is also why we
- 01:33:03 get D cannot set headers error here
- 01:33:06 because it already moved along and
- 01:33:08 executed this code when all of a sudden
- 01:33:10 the parsing of the request finished and
- 01:33:12 it executed this code and tried to again
- 01:33:15 send a response which obviously is too
- 01:33:17 late because it already did here
- 01:33:19 now I know that this is hard to wrap
- 01:33:23 your head around but it is a crucial
- 01:33:25 concept that you can register code
- 01:33:28 functions which run sometime in the
- 01:33:31 future but not necessarily right now and
- 01:33:35 therefore the next line of code this
- 01:33:37 code here can run or will run before
- 01:33:40 this code simply because this is just a
- 01:33:43 callback to be called sometime in the
- 01:33:46 future and this setup is important
- 01:33:49 because otherwise node would have to
- 01:33:51 pause until it's done
- 01:33:53 pause until it wrote the file and if it
- 01:33:56 does that it will simply slow our server
- 01:33:59 down and it's not able to handle our
- 01:34:01 incoming requests or do anything of that
- 01:34:04 kind until it's done and that is not
- 01:34:07 what we want we don't want to block our
- 01:34:10 code execution we always want to be in
- 01:34:12 that wait for a new events loop the
- 01:34:15 event loop and then only execute code
- 01:34:17 once it's due to be executed and never
- 01:34:19 block that event loop for too long of a
- 01:34:22 time and this is why we have this setup
- 01:34:24 and this has one implication for this
- 01:34:27 line and for this line the implication
- 01:34:30 for this line is that we reach it too
- 01:34:32 early so to avoid this we should
- 01:34:34 actually return here we simply return
- 01:34:38 request on so that this gets executed
- 01:34:40 but the line thereafter doesn't and the
- 01:34:43 important application about this line
- 01:34:45 will be discussed in the next lecture
- 01:34:52 so what is wrong with this right file
- 01:34:55 syncline here well it's desync keyword i
- 01:35:00 earlier mentioned that there also is a
- 01:35:02 right file method but we used right file
- 01:35:06 sync the sync here stands for
- 01:35:09 synchronous and this is a special method
- 01:35:13 which will actually block code execution
- 01:35:16 until this file is created now working
- 01:35:20 with files is available in two modes
- 01:35:23 here is the synchronous mode we block
- 01:35:26 execution of the next line of code until
- 01:35:28 this file is done now for this short of
- 01:35:32 a text we enter this is super fast and
- 01:35:35 we won't even notice it but think about
- 01:35:37 a huge file a couple of hundreds of
- 01:35:41 megabytes or even bigger if you do
- 01:35:43 something with that read it copy it
- 01:35:46 whatever it is and you block the code
- 01:35:49 execution then the next line and all the
- 01:35:52 other code will not continue to run
- 01:35:54 until that file operation is done and
- 01:35:57 even new incoming requests of our users
- 01:36:00 would not be handled until that file
- 01:36:03 operation is done and you don't want
- 01:36:06 that therefore you should not use that
- 01:36:08 syntax here you can if you know you'll
- 01:36:11 only have a very short file operation
- 01:36:13 but even then it's better to use this
- 01:36:16 write file method here which actually
- 01:36:19 does not just accept a path and the data
- 01:36:22 but also a third argument and that is
- 01:36:25 again such a callback so a function that
- 01:36:28 should be executed when it's done so
- 01:36:32 here again just as with create server
- 01:36:34 nodejs
- 01:36:36 implicitly registers an event listener
- 01:36:38 for us
- 01:36:39 so here I've has another function and
- 01:36:43 this callback here actually receives an
- 01:36:47 error object which will be null if no
- 01:36:51 error occurred but if some error
- 01:36:53 occurred missing permissions or anything
- 01:36:55 like that you would get it here and you
- 01:36:57 could then handle it gracefully by
- 01:37:00 returning a different kind of response a
- 01:37:02 error response showing to the user that
- 01:37:05 an error occur
- 01:37:05 and otherwise return a normal response
- 01:37:08 now here I won't do error handling and
- 01:37:11 there is really nothing that could go
- 01:37:12 wrong here well of course dive into
- 01:37:14 error handling a bit more later in the
- 01:37:16 course but I will remove my normal
- 01:37:19 response code in there because this
- 01:37:21 response should only be sent if we're
- 01:37:24 done working with the file because that
- 01:37:27 is ultimately team action we want to do
- 01:37:30 up on our request right so now we
- 01:37:33 actually have our event listener with
- 01:37:35 some method or function that will be
- 01:37:38 executed once we're done parsing the
- 01:37:40 request and in that function that will
- 01:37:42 be executed sometime in the future we
- 01:37:44 have yet another event listener this
- 01:37:47 nested function here which will be
- 01:37:49 executed once we're done writing the
- 01:37:50 file and this is actually pretty
- 01:37:53 standard for nodejs you have this
- 01:37:56 event-driven architecture where you
- 01:37:59 basically tell no choice please do
- 01:38:02 something and it will then go ahead and
- 01:38:04 offload that process to the operating
- 01:38:06 system which does use multi-threading
- 01:38:08 and so on and will then continue its
- 01:38:10 event loop to listen for event callbacks
- 01:38:13 and always just dispatch tiny actions
- 01:38:17 like that to never block the code
- 01:38:19 execution and then always just come back
- 01:38:22 once an operation is done by the
- 01:38:24 operating system and so on so this is
- 01:38:26 what noches does here and why it is high
- 01:38:29 performant because it never blocks your
- 01:38:31 code
- 01:38:32 it never blocks the server it just goes
- 01:38:35 ahead and tells the operating system do
- 01:38:37 that do this and then eventually comes
- 01:38:39 back and does something in the callback
- 01:38:41 like send a response which is not a
- 01:38:44 blocking operation because this is super
- 01:38:46 fast just a couple of headers and off
- 01:38:48 you go so I hope this is clear and with
- 01:38:51 that let's restart this by quitting the
- 01:38:54 server rerunning node app and going back
- 01:38:58 to just slash nothing let's enter hello
- 01:39:07 again here and send and in message text
- 01:39:11 we see that again concatenated with an
- 01:39:14 extra character not something we have to
- 01:39:16 worry about right now so you see right
- 01:39:18 file all the works but this is the way
- 01:39:21 you should use it due to the
- 01:39:23 asynchronous nature of no chairs which a
- 01:39:25 hope now became clear because it is a
- 01:39:28 crucial concept of no chairs and one you
- 01:39:31 absolutely have to understand with that
- 01:39:34 let's wrap this module up with these
- 01:39:37 core basics and let's from now on move
- 01:39:39 to a more easier route where we will
- 01:39:42 make our life simpler and not write all
- 01:39:45 this nitty-gritty detail killed on our
- 01:39:47 own but it is super crucial that you
- 01:39:50 understand what's going on here
- 01:39:56 over the last lectures I extensively
- 01:39:59 mentioned how node works with
- 01:40:01 asynchronous code and I mentioned this
- 01:40:04 event loop which is important let me
- 01:40:06 dive deeper into that and deeper into
- 01:40:10 how noches exactly execute your code to
- 01:40:13 stay performant and still be able to
- 01:40:16 handle long taking tasks like working
- 01:40:19 with files or things like that
- 01:40:21 because there is an important concept
- 01:40:23 which you have to understand to
- 01:40:25 understand well what is happening behind
- 01:40:27 the scenes
- 01:40:28 so in our node application we have our
- 01:40:31 code and one important thing to
- 01:40:33 understand and to really keep in mind is
- 01:40:35 that note j/s uses only one single
- 01:40:39 javascript fret a fret is basically like
- 01:40:42 a process in your operating system you
- 01:40:44 could say so it's only using that one
- 01:40:47 thread and the obvious question is how
- 01:40:49 is it then able to handle multiple
- 01:40:51 requests because if we're not able to
- 01:40:55 assign a new fret for each request they
- 01:40:58 ultimately end up all running in one on
- 01:41:01 the same fret and this of course poses a
- 01:41:03 security question can you then access
- 01:41:06 data from request a from request B and
- 01:41:10 most importantly here at this point when
- 01:41:12 we talk about performance there of
- 01:41:14 course all the is the question of does
- 01:41:17 does not mean that if the request a is
- 01:41:19 still doing work requests B can't be
- 01:41:22 handled well both is taken care of of
- 01:41:25 nodejs
- 01:41:25 and at this point of time here i want to
- 01:41:28 focus on the performance question though
- 01:41:30 i'll also briefly touch on the security
- 01:41:33 question now let's start with the
- 01:41:35 performance let's say we have some code
- 01:41:37 which accesses the file system as we
- 01:41:40 already did in this course to now
- 01:41:42 working with files oft is a task that
- 01:41:45 takes longer because files can be very
- 01:41:48 big and it doesn't necessarily complete
- 01:41:50 instantly therefore if we're doing this
- 01:41:53 upon an incoming request a second
- 01:41:55 request might have to wait because we're
- 01:41:58 not able to handle it yet or it even
- 01:42:00 gets a decline so basically our webpage
- 01:42:03 is down for that user now one important
- 01:42:06 construct I already mentioned is that
- 01:42:08 event loop
- 01:42:10 the event loop is automatically started
- 01:42:12 by no chess when your program starts you
- 01:42:15 don't have to do that explicitly no
- 01:42:17 chess
- 01:42:18 does that when well it basically starts
- 01:42:20 running code this is responsible for
- 01:42:23 handling event callbacks though so all
- 01:42:27 these nice functions we basically added
- 01:42:29 thus far in create server for example
- 01:42:32 the event loop is responsible for
- 01:42:35 basically running that code when a
- 01:42:38 certain event occurs you could say it's
- 01:42:40 aware of all these callbacks and
- 01:42:41 basically well execute that code that
- 01:42:44 doesn't help us with our long taking
- 01:42:47 file operation though and it's important
- 01:42:49 to understand that this operation is not
- 01:42:52 handled by the event loop just the
- 01:42:55 callback that we might have to find on
- 01:42:58 write file once it's done dad code will
- 01:43:02 be handled in the event loop but that
- 01:43:03 code will finish fast so basically the
- 01:43:06 event loop will only handle callbacks
- 01:43:09 that contain fast finishing code instead
- 01:43:14 our file system operation and a couple
- 01:43:16 of other long tagging operations are
- 01:43:18 sent to a worker pool which is also spun
- 01:43:21 up and managed by no chess automatically
- 01:43:24 this worker pool is responsible for all
- 01:43:27 the heavy lifting this worker pool is
- 01:43:30 kind of totally detached of your
- 01:43:33 JavaScript code you could say and it
- 01:43:36 runs on different frets it can spin up
- 01:43:38 multiple frets it's closely intervened
- 01:43:41 with your operating system you're
- 01:43:42 running the app on so this is really
- 01:43:44 detached from your code and this worker
- 01:43:47 pool is therefore doing all the heavy
- 01:43:49 lifting if you're doing something with a
- 01:43:51 file well a worker from that pool will
- 01:43:54 take care and will do its job totally
- 01:43:57 detached from your code and from the
- 01:43:59 request and from the event loop the one
- 01:44:02 connection to the event loop we will
- 01:44:04 have though is that once the worker is
- 01:44:07 done so for example once we read a file
- 01:44:10 it will trigger the callback for that
- 01:44:13 read file operation and since the event
- 01:44:16 loop is responsible for the events and
- 01:44:18 the callbacks this will in the end end
- 01:44:20 up in the event loop
- 01:44:22 so they're noches will then basically
- 01:44:25 execute the appropriate callback now
- 01:44:28 this is a lot of behind the scenes stuff
- 01:44:30 which is nice to know you don't have to
- 01:44:32 write any code to make this work this is
- 01:44:35 all built into node.js and if you write
- 01:44:38 code as you learn it in this course you
- 01:44:40 automatically take advantage of this I
- 01:44:42 still of course want you to understand
- 01:44:44 how that works behind the scenes because
- 01:44:46 I believe that helps you understand
- 01:44:48 nodejs better now let's look into that
- 01:44:51 event loop then that event loop is in
- 01:44:55 the end a loop which is run or started
- 01:44:58 by noches
- 01:44:59 that keeps the noches process running
- 01:45:01 and as I just mentioned that handles all
- 01:45:04 the callbacks and it has a certain order
- 01:45:07 in which it goes fruity callbacks so
- 01:45:10 basically it's a loop that just ball
- 01:45:12 keeps on looping unsurprisingly at the
- 01:45:15 beginning of each new iteration it
- 01:45:17 checks if there are any timer callbacks
- 01:45:20 it should execute we haven't set up any
- 01:45:23 timers yet but basically there is set
- 01:45:25 timeout and set interval you might
- 01:45:28 notice from front-end JavaScript to
- 01:45:30 there these methods also exist now in no
- 01:45:33 chess you can also set a timer and
- 01:45:35 basically you set a timer and always
- 01:45:38 pass a method a function that should be
- 01:45:41 executed once that timer completes and
- 01:45:43 nodejs is aware of this and at the
- 01:45:45 beginning of each new loop iteration it
- 01:45:47 executes any do timer called X so any
- 01:45:51 callbacks that have to be executed
- 01:45:52 because of timer completes then as a
- 01:45:55 next step it checks every callbacks for
- 01:45:58 example with we had write or read file
- 01:46:01 we might have a callback because that
- 01:46:03 operation finished and it will then also
- 01:46:05 execute these callbacks now be aware
- 01:46:08 that with IO here I mean generally any
- 01:46:11 input/output operations that typically
- 01:46:15 is file operations but can also be
- 01:46:17 network operations and in general I'm
- 01:46:19 talking about blocking long taking
- 01:46:22 operations now it's important to
- 01:46:24 understand that no chess will leave that
- 01:46:26 face at a certain point of time and that
- 01:46:29 can also mean that if there are too many
- 01:46:31 outstanding callbacks it will continue
- 01:46:34 its loop iteration and postponed
- 01:46:36 these callbacks to the next iteration to
- 01:46:39 execute them after working on these open
- 01:46:42 callbacks and hopefully finishing them
- 01:46:45 all it will enter a paul face the paul
- 01:46:48 face is basically a face where no chairs
- 01:46:52 will look for new i/o events and
- 01:46:55 basically do its best to execute their
- 01:46:58 callbacks immediately if possible now if
- 01:47:02 that is not possible it will defer the
- 01:47:04 execution and basically register this as
- 01:47:06 a pending callback so this is how that
- 01:47:09 works important
- 01:47:12 it also will check if there are any
- 01:47:14 timer callbacks due to be executed and
- 01:47:18 if that is the case it will jump to that
- 01:47:20 timer face and execute them right away
- 01:47:23 so it can actually jump back there and
- 01:47:25 not finish the iteration otherwise it
- 01:47:27 will continue and next set immediate
- 01:47:31 callbacks will be executed in a
- 01:47:33 so-called check face set immediate is a
- 01:47:36 bit like set timeout or set interval
- 01:47:38 just that it will execute immediately
- 01:47:40 but always after any open callbacks have
- 01:47:45 been executed so typically faster than
- 01:47:48 set timeout with one millisecond of open
- 01:47:51 duration let's say but after the current
- 01:47:54 cycle well finished or at least finished
- 01:47:57 open callbacks that were due to be
- 01:47:59 handled in that current iteration and
- 01:48:01 now we're entering highly theoretical
- 01:48:03 terrain and I don't want to dive too
- 01:48:06 deep into that though you will find a
- 01:48:08 couple of resources that do dive deeper
- 01:48:10 at the end of this module in case you
- 01:48:13 want to join you know chess team and
- 01:48:14 really dive super hardcore introduced
- 01:48:17 now we're nearing the end of each
- 01:48:19 iteration cycle and now no chess will
- 01:48:22 execute all closed event callbacks so if
- 01:48:25 you registered any closed events and in
- 01:48:28 our code we haven't but if you had any
- 01:48:30 close events this would be the point of
- 01:48:32 time where no chairs execute stare
- 01:48:34 appropriate callbacks
- 01:48:36 so roughly spoken we have timer
- 01:48:39 callbacks we then have any i/o related
- 01:48:41 callbacks and other event callbacks and
- 01:48:44 set immediate followed by close event
- 01:48:47 called X so close events are basically
- 01:48:49 handled
- 01:48:50 separately or their callbacks are
- 01:48:52 handled separately we should say well
- 01:48:55 and then we might exit the whole node.js
- 01:48:59 program but only if there are no
- 01:49:02 remaining event handlers which are
- 01:49:06 registered and that is what I mean with
- 01:49:08 this Refs
- 01:49:09 equal null thing here internally note J
- 01:49:12 s keeps track of its open event
- 01:49:15 listeners and it basically has a counter
- 01:49:17 references or refs which it increments
- 01:49:20 by 1 for every new callback to this
- 01:49:24 register every new event listener that
- 01:49:26 is registered so every new future work
- 01:49:29 it has to do you could say and it
- 01:49:31 reduces that counter by 1 for every
- 01:49:34 event listener that it doesn't need
- 01:49:35 anymore
- 01:49:36 every callback it finished and since in
- 01:49:39 a server environment we create a server
- 01:49:43 with create server and then listen to
- 01:49:46 incoming requests with listen this is an
- 01:49:48 event which never is finished by default
- 01:49:51 and therefore we always have at least
- 01:49:53 one reference and therefore we don't
- 01:49:55 exit in a normal node web server program
- 01:49:58 we can call the exit function as you
- 01:50:01 already saw and if we do anything else
- 01:50:04 like at the beginning of the course when
- 01:50:06 we just use node to execute a file that
- 01:50:09 did not listen to a web server or on a
- 01:50:12 web server then it all the finishes
- 01:50:14 eventually once it's done with its work
- 01:50:17 so this is how the event loop works and
- 01:50:20 this can be very theoretical all these
- 01:50:24 different phases typically don't matter
- 01:50:27 to you certainly not when getting
- 01:50:29 started with no chairs now consult these
- 01:50:32 advanced resources if you want to learn
- 01:50:34 more for now just be aware of that first
- 01:50:37 picture I showed you of how nodejs
- 01:50:40 handles complex work that there is this
- 01:50:43 worker pool that takes care that your
- 01:50:45 things are not getting plucked and that
- 01:50:48 it therefore stays performant now I also
- 01:50:51 touched on that security thing with that
- 01:50:54 one javascript fret and regarding that
- 01:50:58 we also got no problems by default
- 01:51:00 though I will come back later to
- 01:51:03 how we can manage global data and how we
- 01:51:07 should manage it to ensure that we do
- 01:51:09 not spoil data from request a to request
- 01:51:12 B by default we have some separation
- 01:51:14 because remember that callback method in
- 01:51:17 create server it's executed for every
- 01:51:20 new incoming request and therefore this
- 01:51:22 function only runs for that incoming
- 01:51:24 request and anything we do to the
- 01:51:26 request or a response object there will
- 01:51:28 not be exposed to have a request or
- 01:51:30 response objects because each function
- 01:51:32 is only scoped to itself and not
- 01:51:34 accessible by the average so by default
- 01:51:37 we have that separation due to how
- 01:51:39 JavaScript works now that was a big
- 01:51:43 chunk of theory again not something you
- 01:51:46 have to learn by heart but something
- 01:51:48 where you should at least keep that big
- 01:51:49 picture in mind of how nodejs
- 01:51:52 manages its work
- 01:51:57 so let's wrap this module up and right
- 01:52:00 before we finish let's actually start
- 01:52:02 wrapping it up by improving our code a
- 01:52:04 little bit we got all this code in this
- 01:52:07 file and actually typically you write
- 01:52:10 models or work with multiple files and
- 01:52:13 why don't we create a new file that
- 01:52:16 actually contains our routing logic so
- 01:52:20 the logic where we check the URL and do
- 01:52:22 different things so I'll create a new
- 01:52:24 file here routes dot J s the name is up
- 01:52:28 to you and I get this special item by my
- 01:52:30 IDE it is an old JavaScript file don't
- 01:52:33 be confused and in that file I basically
- 01:52:37 want to have my if statements here and
- 01:52:39 my default response code so I'll cut all
- 01:52:43 of that out of here so that this is a
- 01:52:45 pretty lean file and move it into routes
- 01:52:48 chess now this wouldn't work like that
- 01:52:50 let me say that we'll have to tweak that
- 01:52:52 but this is now the code moved over I
- 01:52:54 don't need the file system in Apps is an
- 01:52:58 important remove that import
- 01:53:00 we do need HTTP because we still use
- 01:53:02 that there and we don't need the URL and
- 01:53:05 method here so let's remove that go over
- 01:53:08 to routes chess add this FS import it
- 01:53:11 and hop and now start working with that
- 01:53:14 now what do we need to do in this file
- 01:53:16 we somehow need to be able to connect
- 01:53:20 app js2 routes chess right because we
- 01:53:22 need to be able to send our incoming
- 01:53:25 request queue that file so to say and
- 01:53:28 for that let's create a new function
- 01:53:32 I'll name it request handler and we can
- 01:53:38 either create a function like this it
- 01:53:40 should receive request and response as
- 01:53:43 arguments just as this function does
- 01:53:46 because will effectively replace that
- 01:53:48 function or we use a es6 function
- 01:53:51 storing it in a constant request handler
- 01:53:55 which looks like this bit of a strange
- 01:53:57 syntax if you've never seen it before
- 01:53:59 but we're essentially creating an
- 01:54:01 anonymous arrow function which we store
- 01:54:03 in a constant and this therefore is the
- 01:54:05 function name now here we again receive
- 01:54:08 requests and response and in
- 01:54:11 that function we now move all that code
- 01:54:14 because that code obviously uses the
- 01:54:15 request and response objects so we need
- 01:54:18 to have them available as local
- 01:54:20 variables and we do now because these
- 01:54:22 arguments are now named this way we also
- 01:54:25 use URL and method so we need to re add
- 01:54:28 these constants by getting that data
- 01:54:31 from the request request URL and request
- 01:54:35 method and now we just need to export
- 01:54:39 this handler we're importing with this
- 01:54:42 required syntax but how are we exported
- 01:54:44 in no chess there are two ways of
- 01:54:47 exporting the first one is to go at the
- 01:54:51 bottom and add module dot exports this
- 01:54:54 is another keyword or object which is
- 01:54:58 exposed globally to you by nodejs which
- 01:55:01 has a exports property and we can assign
- 01:55:04 a value to this like our request handler
- 01:55:08 so this constant which holds this
- 01:55:10 function it's now stored in module
- 01:55:13 exports and since this is a global
- 01:55:15 object exposed by node note is actually
- 01:55:18 able to work with this and we can now
- 01:55:21 import from that routes JS file by
- 01:55:24 requiring it and node will look for
- 01:55:27 module exports and see if something was
- 01:55:30 registered for this file here and we do
- 01:55:34 register something in module exports the
- 01:55:36 request Handler and you can register
- 01:55:38 anything here you can add a new
- 01:55:40 JavaScript object with multiple key
- 01:55:42 value pairs whatever you need here I'll
- 01:55:44 just register my function so now I can
- 01:55:48 get go back to App j/s and import my
- 01:55:51 routes the name of that constant is up
- 01:55:53 to you by requiring it and since this is
- 01:55:57 now not a global module we don't just
- 01:56:01 type routes instead we want to add a
- 01:56:04 local path to it with dot slash and you
- 01:56:08 can omit dot j s because no trace will
- 01:56:11 automatically attach this at the end you
- 01:56:14 can't add it though but I'll just say it
- 01:56:16 type dot slash routes separated from the
- 01:56:20 core modules to make it really clear
- 01:56:21 that this is a custom file and now note
- 01:56:25 go ahead and look for a routes J's file
- 01:56:27 in the same folder as fjs which it will
- 01:56:30 find and in that file it will look for
- 01:56:33 module exports and see what's registered
- 01:56:36 in there and now we export that request
- 01:56:39 handler method and now we can use that
- 01:56:42 it will be stored in that routes because
- 01:56:44 we assign whatever is exported from that
- 01:56:46 file in that routes constant so this
- 01:56:49 routes constant will ultimately hold
- 01:56:51 this function and now we can use that
- 01:56:55 here as a handler routes don't execute
- 01:56:59 it so no parenthesis just pass the name
- 01:57:02 telling node hey please execute the
- 01:57:05 function that's stored in routes for
- 01:57:08 incoming requests and now if we save
- 01:57:11 that and we restart the server and we
- 01:57:14 reload this page this is looking good
- 01:57:17 and this is also looking good we should
- 01:57:20 have tests stored and message to text
- 01:57:23 and we do so now we simply split our
- 01:57:26 code over to files having one file which
- 01:57:29 is very lean that's just spins up the
- 01:57:31 server but and that's important that
- 01:57:34 also creates a connection to another
- 01:57:35 file through that import and through
- 01:57:39 that export where we export our request
- 01:57:43 handler function here this is how that
- 01:57:46 works now one important note about nodes
- 01:57:49 module system the file content here is
- 01:57:52 actually cached by node and we can't
- 01:57:55 edit it externally so if we somehow
- 01:57:57 would define routes as an object and we
- 01:58:00 try to add a new property on the fly
- 01:58:02 here this would not manipulate the
- 01:58:05 original file so this is basically
- 01:58:07 locked not accessible from outside we
- 01:58:10 can only export stuff that we can now
- 01:58:12 read from outside though you could have
- 01:58:15 functions which you export that start
- 01:58:17 changing stuff inside of that file but
- 01:58:20 let's not make the too complicated for
- 01:58:22 now we'll see all of that throughout the
- 01:58:24 course obviously for now we have that
- 01:58:26 connection there's one average syntax
- 01:58:29 you could use instead of module exports
- 01:58:32 sometimes you export many things and you
- 01:58:36 could do that by having an off
- 01:58:38 checked which has like the handler key
- 01:58:41 and that is my request handler function
- 01:58:43 and then also it has the some text key
- 01:58:46 which is some hard-coded text in this
- 01:58:52 case now we would export few things
- 01:58:55 and that is how you can group that or
- 01:58:57 separate these two things and still have
- 01:58:59 one export being managed here which is
- 01:59:01 the most you can have and now in fjs
- 01:59:04 routes would be that object and not that
- 01:59:06 function so here we would have to access
- 01:59:10 the handler property so this property
- 01:59:14 which holds the function reference we
- 01:59:16 want to use and we could also simply
- 01:59:19 output console dot log routes subtext
- 01:59:24 here so this is how we can have multiple
- 01:59:26 exports in one file now you see some
- 01:59:29 hard-coded text here from this console
- 01:59:31 lock and we still have the same
- 01:59:34 functionality as before now there all is
- 01:59:37 a different way of exporting multiple
- 01:59:39 things besides this code which you can
- 01:59:41 of course use you can also have module
- 01:59:44 that exports dot handler request Handler
- 01:59:48 and then all the module that exports dot
- 01:59:52 some text some hard-coded text now it
- 01:59:58 might look different but we still only
- 02:00:00 have one export we still only have
- 02:00:02 module exports which bundles all the
- 02:00:04 exports but we explicitly assign the
- 02:00:07 different properties like this so this
- 02:00:09 is basically equivalent to disk code if
- 02:00:12 I now save this and restart my server
- 02:00:14 oops we see some hard-coded text and if
- 02:00:19 I submit this it also still works last
- 02:00:22 but not least there is a shortcut for
- 02:00:24 this syntax you can now emit module and
- 02:00:27 just write exports this is simply a
- 02:00:29 shortcut supported by nodejs not some
- 02:00:32 general JavaScript magic it's just an
- 02:00:34 explicit shortcut supported by nodejs
- 02:00:37 where now we also have multiple exports
- 02:00:41 being merged together into one export so
- 02:00:44 therefore again when I execute this we
- 02:00:46 see some hard-coded text and some last
- 02:00:50 value being submitted here
- 02:00:53 still works and still ends up in message
- 02:00:57 text so this is how we can connect
- 02:01:00 multiple files by exporting either one
- 02:01:04 element one function as we had it
- 02:01:06 initially with module dot exports equals
- 02:01:10 request handler right this is what we
- 02:01:12 had initially let me comment this out
- 02:01:14 with two slashes in front of it or
- 02:01:17 module exports pointing at an object to
- 02:01:20 combine multiple things or using module
- 02:01:26 dot exports dot handler equals request
- 02:01:29 handler and module dot exports dot some
- 02:01:34 text equal some text or again this
- 02:01:42 shortcut which is the same as this just
- 02:01:44 with this shortcut offered by nodejs
- 02:01:47 so this is how imports and exports work
- 02:01:49 how the module system works and will
- 02:01:51 work with a lot of files throughout the
- 02:01:53 course so this is important to
- 02:01:54 understand with that out of the way
- 02:01:57 let's now finally wrap this module up
- 02:02:03 so let's sum this module up now first of
- 02:02:07 all we had a brief refresher on how the
- 02:02:09 web works and in general it looks like
- 02:02:11 this client so the browser sends a
- 02:02:14 request to the server the server that's
- 02:02:16 a magic reaches out to a database works
- 02:02:19 with files sends back a response can be
- 02:02:21 HTML can be something different and
- 02:02:23 sends it back to the client the browser
- 02:02:25 which then can displayed it and that is
- 02:02:27 the entire flow we also saw in this
- 02:02:29 module now note J ass is the part that
- 02:02:32 runs on the server and regarding its
- 02:02:35 lifecycle there is one important concept
- 02:02:38 and that is that so-called event loop
- 02:02:41 nodejs code runs in a non-blocking way
- 02:02:44 which means we only register a bunch of
- 02:02:46 callbacks and events and nodejs will
- 02:02:49 eventually trigger that code once a
- 02:02:52 certain task is done so that the
- 02:02:54 javascript fret is always free to handle
- 02:02:57 new events new incoming requests and
- 02:03:00 stuff like that a node program can exit
- 02:03:03 if there is no more work to do but on a
- 02:03:06 server this wall should at least never
- 02:03:08 happen because create server registers
- 02:03:11 an event listener for an event which is
- 02:03:13 never done if a new event is triggered
- 02:03:15 so when you request is received this
- 02:03:18 does not mean that node n registers the
- 02:03:21 event listener instead we keep on
- 02:03:23 listening for more requests and that is
- 02:03:25 of course how a server should behave so
- 02:03:27 it's this cycle that's important to
- 02:03:29 understand and that we have this loop
- 02:03:31 which always keeps on going keeps on
- 02:03:33 waiting for new events and which does
- 02:03:35 something when some event happens and
- 02:03:38 then basically dispatches some actions
- 02:03:40 to you the operating system you could
- 02:03:43 say for example and then again frees up
- 02:03:46 the thread now this all involves a lot
- 02:03:50 of asynchronous code which we saw with
- 02:03:52 all the callbacks the JavaScript code
- 02:03:55 should be non-blocking so we have this
- 02:03:57 callback an event-driven approach where
- 02:04:00 we are able to register some code to be
- 02:04:03 executed in the future instead of
- 02:04:05 running right away and blocking the main
- 02:04:08 threat because this has to be avoided
- 02:04:10 under all circumstances and Noches
- 02:04:13 is built around that concept of avoiding
- 02:04:16 this issue
- 02:04:17 we also saw how to work with requests
- 02:04:20 and responses denote J s way we saw that
- 02:04:23 we have to parse the request data which
- 02:04:26 arrives in chunks and that we can use
- 02:04:29 this concept of streams and buffers
- 02:04:32 which I explained and that we should
- 02:04:34 avoid sending double responses so that
- 02:04:37 after rest end you must not send another
- 02:04:41 response and this can help me easily if
- 02:04:43 you forget about that asynchronous
- 02:04:46 nature and that a line of code you write
- 02:04:48 might not execute immediately so
- 02:04:51 depending on where you write it if it's
- 02:04:53 an event listener it will not execute
- 02:04:55 immediately that is what I mean and that
- 02:04:57 is what is important to keep in mind
- 02:04:59 here we also learned that note J s is
- 02:05:03 all about using its built-in
- 02:05:05 functionalities and whilst there are
- 02:05:07 some global variables or objects or
- 02:05:11 functions we can use this also means
- 02:05:13 that we should use its core modules core
- 02:05:16 modules are things like the HTTP DFS or
- 02:05:19 the path module there are more and you
- 02:05:21 can learn all about them in the official
- 02:05:24 noches
- 02:05:24 Doc's of course will also use quite a
- 02:05:27 lot of them throughout this course and
- 02:05:28 these core modules give us a couple of
- 02:05:31 different functionalities that allow us
- 02:05:33 to basically do whatever we ever could
- 02:05:36 want to do on a server like create a new
- 02:05:40 server with the help of the HTTP module
- 02:05:42 they're imported why adi require syntax
- 02:05:46 and we can only use them in the file
- 02:05:49 into which we import them and if you
- 02:05:50 want to use them in two different files
- 02:05:52 we have to import them in both files
- 02:05:54 separately now that leads us to the node
- 02:05:57 module system and this basically works
- 02:06:00 with the help of this require keyword
- 02:06:02 which pulls some functionality from one
- 02:06:06 of our files if we start with slash or
- 02:06:08 dot slash or from a core or third-party
- 02:06:12 module we haven't used any third-party
- 02:06:15 modules thus far but we'll all do that
- 02:06:17 soon and it basically pulls in whatever
- 02:06:20 we export there and stores it in a new
- 02:06:22 variable or constant as we did it in
- 02:06:25 this module and export is an important
- 02:06:28 keyword here we do export with the
- 02:06:31 of module dot exports or for multiple
- 02:06:34 exports with the exports shortcut I
- 02:06:37 showed you in the last lectures so this
- 02:06:40 is what we learn in this module and I
- 02:06:42 know that this was a lot of theory or
- 02:06:45 nitty-gritty stuff about no chess
- 02:06:48 doesn't look too easy and beautiful but
- 02:06:50 it'll get way more beautiful from now on
- 02:06:52 it is super important to never forget
- 02:06:55 what no chess isn't dust for you though
- 02:06:58 because many courses right away start
- 02:07:00 with expressed J s which will all use
- 02:07:03 starting soon and therefore you never
- 02:07:06 really learn what's happening under the
- 02:07:08 hood which is sad because this is
- 02:07:09 important and makes you a better note
- 02:07:12 developer that let's move on