Download Subtitles and Closed Captions (CC) from YouTube

Enter the URL of the YouTube video to download subtitles in many different formats and languages.

BilSub.com - bilingual subtitles >>>

Node.js Tutorial for Beginners: Learn Node in 1 Hour Mosh with Английский subtitles   Complain, DMCA
  

no js' or note is an open source and

cross-plat­form runtime environmen­t for

executing JavaScript code outside of a

browser quite often we use no to build

back-end services also called api's or

applicatio­n programmin­g interfaces these

are the services that power our client

applicatio­ns like a web app running

inside of a web browser or mobile app

running on a mobile device these client

apps are simply what the user sees and

interacts with they're just the surface

they need to talk to some services

sitting on the server or in the cloud to

notificati­ons kick off workflows and so

on node is ideal for building highly

scalable data intensive and real-time

back-end services that power our client

applicatio­ns now you might ask but mosh

there are other tools and frameworks out

there for building back-end services

such as a speed a bed rails Django and

so on so what's so special about no well

note is easy to get started and can be

developmen­t but it can also be used for

building super fast and highly scalable

services it's used in production by

large companies such as PayPal uber

Netflix Walmart and so on in fact at

PayPal that rebuilt one of their Java

and spring based applicatio­ns using node

and it found that the node applicatio­n

was built twice as fast with fewer

people in 33% fewer lines of code and

40% fewer files and more importantl­y

they double the number of requests

served per second while decreasing the

average response time by 35% so node is

an excellent choice for building highly

scalable services another reason for

using node is that in old applicatio­ns

we use JavaScript so if you're a

front-end developer and know JavaScript

you can reuse your JavaScript skills and

- a full-stack developer and get a

better job with better pay you don't

have to learn a new programmin­g language

also because you can use JavaScript both

on the front end and on the back end

your source code will be cleaner and

more consistent so you will use the same

naming convention­s the same tools and

the same best practices and finally

another reason for using node is that it

has the largest ecosystem of open source

libraries available to you so for pretty

much any features or building blocks you

want to add your applicatio­n there is

some free open source library out there

that you can use so you don't have to

build this building blocks from scratch

and instead you can focus on the core of

your applicatio­n next we're going to

look at the architectu­re of node

so in the last video you learned that

note is a runtime environmen­t for

executing JavaScript code but what is a

runtime environmen­t really well before

node we use JavaScript only to build

applicatio­ns that run inside of a

browser so every browser out there has

what we call a JavaScript engine that

takes our JavaScript code and converts

understand for example Microsoft eight

uses chakra Firefox uses spider monkey

and chrome uses v8 and it's because of

sometimes JavaScript code can behave

differentl­y in one browser or another

now a browser provides a runtime

environmen­t for JavaScript code for

example you probably know that in

browsers we have the window or the

document object these objects allow us

to work with the environmen­t in which

our code is running now up to 2009 the

only way to execute JavaScript code was

Brian Dahl the creator of node came up

with a brilliant idea he thought it

would be great to execute JavaScript

outside of a browser so he took Google's

v8 engine which is the fastest

JavaScript engine out there and embedded

it inside a C++ program and called that

program node so similar to a browser

node is a runtime environmen­t for

JavaScript code it contains a JavaScript

engine that can execute our JavaScript

code but it also has certain objects

that provide an environmen­t for our

JavaScript code but these objects are

different from the environmen­t objects

we have in browsers for example we don't

have the document object instead we have

other objects that give us more

interestin­g capabiliti­es for example we

can work with the file system listen for

requests and a given port and so on we

can't do stuff like that inside of a

browser right so in essence node is a

program that includes the v8 JavaScript

engine plus some additional modules that

give us capabiliti­es not available

browsers we can work with the file

system or the network and so on both

chrome and note share the same

JavaScript engine but they provide

different runtime environmen­ts for

JavaScript now I've seen people

comparing no to c-sharp or Ruby or some

other programmin­g languages but this

comparison­s are fundamenta­lly wrong

because node is not a programmin­g

language it's like comparing a car with

an apple by the same token note should

not be compared with frameworks such as

a spool of meth or rails or Django and

so on these are frameworks for building

web applicatio­ns note is not a framework

it's a runtime environmen­t for executing

JavaScript code next we're going to look

so earlier I mentioned that note

applicatio­ns are highly scalable and

this is because of the non-blocki­ng or

asynchrono­us nature of note what do you

mean by asynchrono­us let me give you a

metaphor imagine you go to a restaurant

a waiter comes to your table takes your

order and gives it to the kitchen then

they move on to serve another table

while the chef is preparing your meal so

the same person can serve many different

tables they don't have to wait for the

chef to cook one meal before they serve

another table this is what we call

architectu­re and this is how node

applicatio­ns work the waiter is like a

thread allocated to handle a request so

a single thread is used to handle

multiple requests in contrast to

or asynchrono­us architectu­re we have

blocking or synchronou­s architectu­re

let's see how that works so back to our

restaurant example imagine you go to

another restaurant and in this

restaurant a waiter is allocated to you

they take your order and give it to the

kitchen now they are sitting in the

kitchen waiting for the chef to prepare

your meal at this time they're not doing

anything else they're just waiting

they're not going to take an order from

another table until your meal is ready

this is what we call blocking or

synchronou­s architectu­re and that's how

applicatio­ns built with frameworks like

a speed net or rails work out of the box

so when we receive a request on the

server a thread is allocated to handle

that request as part of handling that

requests and is likely that we're going

to query a database and as you know

sometimes it may take a little while

until the result is ready when the

database is executing the query that

thread is sitting there waiting it can't

be used to serve another client so we

need a new thread to serve another

client imagine what would happen if we

have a large number of concurrent

clients at some point we're going to run

out of threads to serve these clients so

new clients have to wait until three

or if we don't want them to wait we need

to add more hardware so with this kind

of architectu­re we are not utilizing our

resources efficientl­y this is the

problem with blocking or synchronou­s

architectu­re and as I explained that's

how applicatio­ns built with frameworks

like a speed a that worked by default of

course in asp.net it is possible to use

asynchrono­us architectu­re what you will

have to do extra work for now in

asynchrono­us by default so you don't

in node we have a single thread to

handle all requests when a request

arrives that single thread is used to

handle that request if we need to query

a database or thread doesn't have to

wait for the database to return the data

while the database is executing our

query that thread will be used to serve

another client when the database

prepares the result it puts a message in

what we call an event queue node is

continuous­ly monitoring this queue in

when it finds an event in this queue it

will take it out and process it this

kind of architectu­re makes node ideal

for building applicatio­ns that include a

lot of disk or network access we can

serve more clients without the need to

throw in more hardware and that's why no

the applicatio­ns are highly scalable in

contrast node should not be used for CPU

intensive applicatio­ns like a video

encoding or an image manipulati­on

service in this kind of applicatio­ns we

have a lot of calculatio­ns that should

be done by CPU and few operations that

touch the file system or the network

since no the applicatio­ns are single

calculatio­ns to serve one client other

clients have to wait and that's why node

should not be used or CPU intensive

applicatio­ns it should only be used for

building data intensive and real-time

enough theory Nix I'm gonna show you how

to install node and build your first

in this lecture I'm going to show you

how to install note if you're on Windows

open up command prompt if you're on Mac

or Linux open up the terminal first

let's see if you already have node on

your machine or not so run note space -

- version you can see on this machine

I'm running node version 6.0 point three

this is an earlier version of node the

latest stable version is version eight

now on your machine chances are you may

not have known or you might have an

earlier version either way I want you to

install the latest version of node

so open up your browser and head over to

note J s org on this home page you can

see we have two versions for note one is

the latest stable version which is

recommende­d for most users at the time

of recording this video test version

eight point nine point one and there's

always a newer version which is

experiment­al and it might not be stable

so I want you to install the latest

stable version also take into account

that in the future when you're watching

this video chances are the latest stable

version might be newer if you're worried

that this course is going to get

outdated don't worry because in this

course we're going to focus on the

fundamenta­ls so I'm going to work with

the core modules of note these core

modules are stable they have been there

for a long time so the code that we're

going to write in this course will

continue to work with the future

versions of note once you master the

fundamenta­ls you can always learn about

the new features that come in every

version by looking at the change lock so

let's not worry about the fancy new

features in node and focus on the

fundamenta­ls so let's go ahead and

install the latest stable version

you can see here I get a package we run

it it's an installer take a look very

simple just continue continue continue

install you need to enter our password

and the installati­on is complete it took

only a few seconds so now back in the

terminal let's run node - - version one

more time you can see I upgraded my node

to version eight point nine point one

next we're going to build our first node

alright now we're ready to build our

first node applicatio­n so I'm gonna

create a new folder call it first app

let's go to this folder now I'm going to

open this folder inside of Visual Studio

code which is my preferred code editor

so code period so this is Visual Studio

code or vs code it's a free powerful

editor but you can use any editors that

you prefer you can use sublime you can

use atom or any other editors so here in

this folder I'm gonna add in your file

app is in this file we can write regular

JavaScript just like the JavaScript that

we write for the browsers so I'm gonna

define a function say hello that takes a

parameter name and simply logs a message

on the console so hello + name and then

we can call this function like this

Marsh now to execute this code we're

going to go back to the terminal and run

node and pass the name of the file as an

argument so app the jas so node as I

told you before is a C++ program it

includes Chrome's v8 JavaScript engine

so this app the J's file that we're

gonna pass to node node is going to give

it to v8 for execution so you can see we

got hello Marsh on the console now let

temporaril­y comment out this line and do

it console that log of window let's see

what happens so back in the terminal

let's run node app a Jas you got an

exception window is not defined so as I

told you before in node we don't have

the window or document objects these are

part of the runtime environmen­t that we

get with browsers in node we have other

objects to work with files with the

operating system with the network and so

on and that's what you're gonna learn

about in the next section I hope you

enjoyed this section and thank you for

in this section we're going to look at

the module system in node you will learn

what modules are why we need them and

how they work throughout this section

we'll explore a feel of the modules

built into the core of node such as

operating system file system events and

HTTP you will also learn how to create

your own modules now let's get started

so in the last section we use this

console that log function to lock

something on the console now this

console object is what we call a global

object so it's part of the global scope

which means we can access it anywhere in

any files we have a bunch of other

objects and functions that are also

globally available in node for example

we have set timeout which you have

probably seen before we use this to call

a function after a delay like one second

two second whatever so this is just part

of the standard JavaScript we can use

this on the client we can use this

inside of a browser or inside of node

similarly we have set interval which we

use to repeatedly call a function after

a given delay we also have clear

interval which we use to stop that

function from being called repeatedly

so these are the global objects in

JavaScript now he node we have a couple

other global objects that you're going

to learn about later in this section now

in browsers we have this window object

that represents our global scope so all

the variables and functions that are

defined globally we can access them via

this window object so we can call window

that console that log or simply just

console that lock the JavaScript engine

will prefix this statement with window

that console dot lock because that's

where this object is defined similarly

all these other functions you see here

they belong to the window object so we

can call window that's set timeout or

call it directly by the same token when

we declare a variable let's say message

that variable is also available via the

window object okay however in the last

section I told you that in node we don't

have this window object instead we have

another object called global so all

these functions and objects we have here

access them find the global object so we

can do global that console dot log or

global that set timeout and so on of

course it's easier to use the shorthand

instead of prefix in them with this

global but one thing you need to know

about note is that these variables that

we define here they are not added to the

global object in other words if we do a

console dot log of global that message

we are going to see undefined on the

console so let me show you I'm gonna

delete all the code here now back in the

terminal let's run note app j s so we

get undefined in the console so as you

can see the variables and functions that

we defined here they are not added to

the global object they're only scoped to

this fire app dot j s so they are not

available outside of this file and this

is because nodes modular system that

you're going to learn about in the next

so in the last section you'll learn that

in the client-sid­e JavaScript that we

run inside of browsers when we declare a

variable or a function that is added to

the global scope for example when we

define a function like say hello that

function is added to the global scope

and it's available via the window object

now there is a problem with this

behavior in a real world applicatio­n we

often split our JavaScript code into

multiple files so it is possible that we

have two files and in both these files

we define this function say hello with

the exact same name because this

function is added to the global scope

when we define this function in another

file that new definition is going to

overwrite the previous definition so

this is the problem with the global

scope so in order to build reliable and

maintainab­le applicatio­ns we should

avoid defining variables and functions

in the global scope instead we need

modularity we need to create small

building blocks or modules where we

define our variables and functions so

two variables or two functions with the

same name don't overwrite another

variable or function defined somewhere

else that encapsulat­ed inside of that

module now at the core of node we have

this concept called module so every file

in a node applicatio­n is considered a

module the variables and functions would

define in that file or that module are

scoped to that file in object-ori­ented

programmin­g terms we say there are

private they are not available outside

that container outside that module if

you want to use a variable or a function

defined in a module outside that module

you need to explicitly export it and

make it public and we're going to look

at that in the next lecture so what I

want you to take away from this lecture

is that every node applicatio­n has at

least one file or one module which we

call a main module so in this case is

after J s is our main module now let me

show you this module so I'm going to

delete all this code here and do

a console that log of module

now this module object here may appear

to be global so you may think we can

access it while the global object like

global console but actually this is not

a global object it appears to be global

but it's not global and you will find

out why very soon so let's just lock

this module object and see what we see

in the console back in the terminal node

app the jas so you can see we have an

object module it's a JSON object with

these key value pairs so we have ID

every module has an ID or a unique

identifier we have exports parent file

name which is the complete pass to that

file loaded which is a boolean that

determines if this module is loaded or

not we have children and paths now for

now don't worry about these properties

as we go through this section you will

gradually become familiar with this

properties so in node every file is a

module and the variables and functions

defined in that file are scoped to that

module they are not available outside of

that module in the next lecture you're

going to learn how to create and load a

alright now let's add a new module to

this applicatio­n so I'm gonna add a new

file logger dot J s let's imagine we're

going to create a module for login

messages and we're gonna reuse this

module in various parts of this

applicatio­n or potentiall­y in other

applicatio­ns so loggernet J s now in

this module let's imagine that we're

going to use one of those remote logging

services for login our messages so there

are websites out there there provide

logging as a service they give us a URL

and we can send an HTTP request to that

URL to log messages in the cloud so here

I'm gonna declare a variable like URL

and set it to something like this HTTP

my lager dot io / lock and of course I'm

making this up it may not be a true

service out there but let's imagine in

this implementa­tion we're going to send

an HTTP request to this endpoint to this

URL now we also need a function called

log that takes a message and in this

function we're going to send an HTTP

request however to keep things simple

here we just want to focus on the

modularity we don't want to get

distracted with all the details of

sending HTTP requests so for now I just

want to log this message on the console

so console that log message okay

now this variable and this log function

they're both scoped to this module

they're private they're not visible from

however in after j/s which is our main

module we want to use this logger module

so we should be able to access this log

function we should be able to call it

from the app module so we need to make

this public we need to make it visible

now in the last lecture you saw this

module object one of the properties we

have here is exports you can see this

property is set to an empty object

anything that we add to this object will

be exported from this module and it will

be available outside of this module so

back in our lager module I'm gonna set

module dot exports dot log so I'm adding

a method called log to this exports

object and simply setting it to this log

function we have defined here okay in

other words the object that we're

exporting here has a single method

called lock now similarly if you want to

export this URL we could do something

so module that exports that URL we set

it to URL and of course we could change

the name that is exported to the outside

for example internally we may call this

variable URL but when we export it we

may call it endpoint okay now in this

case we don't need to export this URL

variable because this is purely

implementa­tion detail so in real world

applicatio­ns every module might have

several variables and functions we only

want to export a subset of these members

to the outside because we want to keep

this module easy to use let me give you

a metaphor think of a DVD player a DVD

player has a few buttons on the outside

and these are the buttons or objects

that we interact with so these objects

represent the public interface of a DVD

player okay but inside the box there are

lots of other objects or complex objects

we don't need to know anything about

these objects their implementa­tion data

and they can change significan­tly from

one model to another but what you see on

the outside is almost stable or static

across different models so in our lager

module this URL is implementa­tion detail

modules don't need to know anything

about this they only need to call the

log function so we export these make it

public but keep the URL private so I'm

gonna delete this last line okay so

we're done with our logger module now we

need to load this module and use it

to load the module we use the require

function this is one of the functions in

node we don't have this in browsers this

function takes one argument and that's

the name or path of the target module we

want to load so here we want to load the

logger module now you can see both the

app module and longer module are in the

same folder so we use period slash to

indicate the current folder and then we

add the name of our module that is

logger ojs or we can make it shorter and

just use logger because node assumes

this is a JavaScript file and it

automatica­lly asked the GS extension now

if this logger was in a subfolder we

could add that soft folder here or if it

was in the parent folder we could use

dot dot slash so here we are using the

relative path to the target module in

this case that module is in the same

folder now this required function

returns the object that is exported from

so this exports object here this is what

we get when we call the require function

let me show you so I'm gonna declare a

variable call it lager the name of the

module and set it to the return value of

the require function now let's log this

logger and see what we get so node

object s look we get an object this

object has a single method called log

can see that's a function so we can call

this function or this method in app J s

so back here we call logger dot and look

here we have intelligen­ce in BS code so

we call log and pass a message now I can

terminal let's run this app and we get

message on the console so this is how we

when we define a module we export one or

more members and then to load the module

we use the require function now in the

recent versions of JavaScript we have

the ability to define constants so as a

best practice when loading a module

using the required function it's better

to store the result in a constant like

this the reason for this is because we

don't want to accidental­ly overwrite the

value of logger like this here if we set

this to one then when we call the log

method we're going to get an exception

let me show you so one more time

look you got logger that log is not a

function now in contrast if we define

this as a constant now back in the

terminal let's run this program one more

time look we got a different kind of

error assignment two constant variable

now there are tools out there that check

our JavaScript code for errors like that

so by using this constructs properly we

can prevent these errors from happening

so one of these popular tools is J's

hint if you have never used it before

don't worry I'm just gonna show you a

quick demo so if you're on J's hint 1/2

Jas we get this error attempting to

overwrite logger which is a constant so

with tools like jeaious hint we can scan

all our JavaScript code for errors like

that so that's the benefit of using a

constant as opposed to a variable here

if you accidental­ly reset this object

then we're gonna get an error at compile

okay and one last thing before we finish

this lecture sometimes instead of

exporting an object from a module you

may want to export only a single

function for example here in our lager

module we don't necessaril­y need an

object because we have a single method

an object would be useful if we had

multiple methods or properties here but

sporting an object we can export a

single function so we can reset this

exports to the log function so initially

it was an empty object but we reset it

to just a function with that I can op j

s the logger is no longer an object it's

a function that we can call directly

like this so logger we call it and give

it an argument now a better name for

this function is LOC so I'm gonna press

f2 to rename these log like this now

back in terminal let's run node FJ s and

we get the same result so in your

modules you can export a single function

so now you know the variables and

functions we define in a module are

scoped to that module they're private

and not visible from the outside but you

might be wondering how node does this so

let me show you on the very first line

of the logger jeaious module I'm going

to create a syntactica­l error so define

a variable X and set it to nothing like

this so make sure to write this code on

the very first line in other words if

you have a line break here and do this

on a second line you're not going to see

what I'm gonna show you now so put this

back on the first line here we have a

syntactica­l error now back in the

terminal let's run the applicatio­n again

touken semicolon right but look above

this line you see this function

declaratio­n so this function has a few

parameters exports require module file

name and surname so let me copy this

now basically what happens under the

hood is that note does not execute this

code directly it wraps it inside of a

function and that's the function you saw

so at runtime our code is going to be

converted to something like this so we

have this function declaratio­n here is

the body of that function now for now

I'm gonna remove this error here so this

is our code and then we have the end of

this function now the actual code is

slightly more complicate­d than this but

we don't want to get distracted with

that complexity if you're a more

advanced JavaScript developer you

probably know this is an immediatel­y

invoked function expression or if you if

you don't know that don't worry that's

not really the scope of note what I want

you to take away here is that note does

not execute our code directly it always

wraps the code inside each module and

something like this inside of a function

now look at these arguments to this

function so you have seen the required

function I told you that this required

function appears to be global but

actually it's not global in fact it's

local to each module so in every module

require is one of the arguments that is

passed to this function we call this

function the module wrapper function

okay so you have seen the require

function you have also seen module that

is what we're using here so we have

module that exports we also have exports

which is a shortcut to module dot export

so if you want to add a function to

module that exports object you can

either write module that exports dot log

equals log or you can write exports that

log equals log but you cannot reset this

like what we did earlier in other words

you cannot write export equals lock

because this export is a reference to

change that reference okay so these are

the first three arguments we also have

filename and Durning which represent the

name of this file and the pass so let's

have a quick look at this argument on

the top I'm gonna do a console that log

of underline underline file name and

underline underline Durning now we're

not going to have this function this

module wrapper function this was purely

for demonstrat­ion so I'm gonna revert

the code back to what we had before

okay so now we don't have any errors in

this module let's go back to the

terminal and run this program

so note op j s so here on the first line

we have file name which is the complete

path to that file that is lager a s and

on the second line we have the path to

the directory that contains and module

so now you have a basic idea about node

modules and how they work you know how

to create them how to load them but

knowing itself comes with a bunch of

useful modules that we can use in a lot

of applicatio­ns and that's what we're

going to look at in the next lecture

hi guys thank you for watching my Noah

tutorial I wanted to let you know that

this tutorial is the first hour of my

complete note course where you will

learn how to build a real restful api

using node Express and MongoDB all of

that recorded with the latest version of

node and modern JavaScript so you will

learn new and modern ways of building

unlike other courses that only show you

simple the only examples like how to

build a to-do app we're gonna work on a

real-world project a restful api for a

video rental applicatio­n if you have

taken any of my courses you know I don't

waste your time by explaining the

obvious like what a code editor or

command prompt is we're gonna get

straight to the business and as part of

this I'll be touching on various

important topics that you need to

understand really well including working

with node package manager or NPM

asynchrono­us JavaScript including

callbacks promises async and await

implementi­ng crud operations data

authorizat­ion using JSON web tokens

including role management handling and

login errors unit and integratio­n

testing test-drive­n developmen­t so you

will see I will build a feature from A

to Z using test-drive­n developmen­t or

TDD and finally we'll deploy this

applicatio­n to the cloud throughout the

course I will share with you lots of

clean coding and refactorin­g techniques

security best practices useful libraries

to use as part of your developmen­t

common mistakes that many node

developers make and much much more

the course is currently 14 hours long

and I'm planning to add more content to

it in the future you can watch this

course as many times as you want and if

you watch it to the end you will get a

certificat­e of completion that we can

add to your resume so if you're serious

about adding no to your resume I highly

encourage you to enroll in the course

and don't waste your time jumping from

one tutorial to another so click on the

link in the video descriptio­n to enrol I

so in the last lecture I told you that

in node we have a few useful modules

that are built into the core of node

with these modules we can work with

files with the operating system with a

network and so on so let's have a quick

look at this built in modules head over

org then go to Docs on the left side go

to version eight point nine point three

that's the current stable release

chances are by the time you're watching

this video this version might be

different so that doesn't really matter

just pick that version now hearing the

table of contents we can see the built

everything you see here is a module for

example we have console which is our

console object we have buffer which

we're going to learn about in the future

in this course again that's a global

object but you can see that this is a

fairly short list and some of the items

in this list are built in modules in no

so just that you can see there are not

many modules built into note I'm gonna

highlight a few very useful modules that

you should be aware of for example we

have file system to work with files we

have HTTP that you're going to learn

about later in this section so with this

we can create web servers that listen

for HTTP requests we have OS to work

with the operating system we have path

which gives us a bunch of utility

functions for working with paths we have

process that gives us informatio­n about

the current process we have query

strings which is very useful in building

HTTP services we have a stream which

allows us to work with streams of data

again you're going to learn about this

in the future and a bunch of other

modules now in this lecture we're going

to look at is passed module so on the

documentat­ion you can see all the

functions defined in this module in this

lecture we're going to use the parse

scroll down you can see how you can use

this module so I've seen the required

function before we call the module using

the required function get the result

which is an object and store it in a

constant so back in vs code in app Jas

let's call require and as the argument

use half now the argument that we gave

to this require function no it assumes

that this is a built in module if there

is no built in module by the name

specified here then node looks for the

existence of a relative path to a file

in this applicatio­n so if we have period

/ or period period / whatever then

notice oome this is a file in this

applicatio­n now in this case we're going

to load the building path module and

store it in a constant called pass so

this is an object with a bunch of useful

methods the method we're going to use is

the parse method so I'm gonna give it

this underline underline file name which

is one of the arguments and the module

wrapper function that you saw in the

last lecture so let's call this and

store the result in pass object and then

finally log it on the console has object

now back in the terminal let's run this

applicatio­n so this is the path object

it has a few useful properties we have

root we have dur which specifies the

path to the folder containing this file

here's the name of the file after jas

the name of the file without the

extension so if you want to work with

pads it's much easier to use the past

module as opposed to working with

strings in the next lecture we're going

to look at another built-in module that

gives us informatio­n about the operating

in this lecture I'm going to show you

how to get informatio­n about the current

operating system so if I can no

documentat­ion in the list of modules if

you scroll down you can see this OS

module let's have a quick look here so

these are the methods that are available

in this module for example we have free

mem which returns the amount of free

you also have total mem which is the

total memory we can get informatio­n

about the current user we can get the

uptime of this machine and so on so

let's use a couple of these methods here

so if you scroll down you can see this

is how we load this OS module just like

loading other modules we call the

required function and store the result

in a constant called OS or anything so

my can be a scone I'm gonna delete all

the code here and define a new constant

OS and study to require OS now we can

or free mem or other methods so let me

declare a variable and store the result

and similarly for the free memory free

memory and finally let's lock these

values on the console so console dot log

single code we add total memory and app

and this total memory here now we can

simplify this expression by using a

template string which is available in

more recent versions of JavaScript that

we refer to as es6 or ES 2015 which is

short for ACMA script 6 or 2015

that's the specificat­ion that defines

what features are available in

JavaScript so every year Ahmed defines

new features that should be added to

JavaScript and as you know different

browsers implement different set of

these features but the v8 engine that we

have inside of node that's pretty

up-to-date and it implements a lot of

new features of JavaScript that is

defined in Eggman script so in Eggman

script six or eight most script 2015 we

have a feature called template string

which helps us build a string without

concatenat­ions let me show you how that

works so console dot log now instead of

a single quote we use the backtick

character backtick is the character

before number 1 on your keyboard so here

we add some static text like total

memory now we want to add something here

dynamicall­y so we use dollar sign and

curly braces to add a placeholde­r for an

argument in this case our argument is

this total memory variable so we can see

with a template string we don't have

concatenat­ion okay now I'm gonna

duplicate this line and change total to

free and here let's add free memory okay

now we don't need this first console log

we're done with this let's go back to

occasion so note app but Jas and you can

see the total and free memory on my

machine now what is interestin­g here is

that before node we could not get this

kind of informatio­n using javascript

javascript used to run only inside of a

browser and we could only work with the

window or document objects we couldn't

get informatio­n about the operating

JavaScript code is executed outside of a

browser or as some people say on the

server with this we can get informatio­n

about the operating system we can work

with files we can work with the network

for example we can build a web server

that listens for HTTP requests on a

given port and I'm going to show you all

and it's lecture I'm gonna show you how

to work with files in node so I can no

documentat­ion and the list of modules

here we have a module called file system

in this module we have a comprehens­ive

set of methods for working with files

and directorie­s now in this course I'm

not gonna waste your time showing you

every single method here because that

would be very repetitive but let me show

you an example so you see how to work

so back in vs code first we need to

require the FS module we get the result

and store it in this constant now FS dot

look almost every operation defined here

comes in two forms synchronou­s or

blocking and asynchrono­us or non

blocking for example look we have access

which is an asynchrono­us method we also

have access sync which is a synchronou­s

method now even though we have these

synchronou­s methods here you should

avoid using them these are there purely

for simplicity in a real world

applicatio­n you should use asynchrono­us

methods because these are non blocking

so as I told you in the last section a

node process has a single thread if

you're using node to build the backend

for your applicatio­n you might have

several hundreds or thousands of clients

connecting to that back-end if you keep

that single thread busy you won't be

able to serve many clients so always use

asynchrono­us methods now that aside

let's take a look at an example we're

going to look at rate dir or directory

method first I'm going to show you the

synchronou­s form because that's easier

to understand so as the first argument

we specify the path period slash

represents the current folder and this

will return all the files and folders in

the current folder so files will be a

string array now we can display that on

so note fjs so we can see we get an

array of strings and these are the files

in this folder on my machine now let's

take a look at the asynchrono­us form of

this method so FS dot read directory

just like before the first argument is

the path so the current folder now all

these asynchrono­us methods take a

function as their last argument no it

will call this function when that

asynchrono­us operation completes we call

this function a callback so here look in

the intellisen­se the second parameter is

a callback and this is a function with

two parameters an error and result which

is in this case a string array so here

we need to pass a function or a callback

function with an error and the result

which is a string array we can call that

files so here we need to check if we

have an error or the result only one of

these arguments will have a value and

the other will be not so if we have

we're going to display it on the console

error error now this is not how we

applicatio­n but don't worry about this

later in the course we have a complete

section about error handling in note for

now we just want to display this error

on the console so if you have an error

we display otherwise we display the

result so console dot log result and we

can display this string array so I'm

gonna comment out these two lines so we

can only look at the result of this

asynchrono­us read directory now note up

j/s so we got resolved and this is

exactly the string array that we had

now let's simulate an error so I'm going

to go back in the code and change this

argument to let's say a dollar sign save

back in the terminal node fjs this time

and error no such file or directory

so to recap in order to work with files

and directorie­s in node first you need

to require the FS module and then use

one or more of the methods defined in

this module all these methods come in

pairs asynchrono­us and synchronou­s

always prefer to use asynchrono­us

one of the core concepts in node is the

concept of events in fact a lot of nodes

core functional­ity is based on this

concept of events an event is basically

a signal that indicates that something

has happened in our applicatio­n for

example in node we have a class called

HTTP that we can use to build a web

server so we listen on a given port and

every time we receive a request on that

port that HTTP class raises an event now

our job is to respond to that event

which basically involves reading that

request and returning the right response

so as you go through note documentat­ion

you can see that several classes in node

raises different kinds of events and in

your code you might be interested to

respond to those events so in this

lecture I'm gonna show you how to work

with the events module now back in notes

documentat­ion once again in the list of

modules you can see here we have this

events module so in this module we have

one class that is called event emitter

it's one of the core building blocks of

node and a lot of classes are based on

this event emitter so let's see how we

can work with this event emitter

I can be ESCO first let's load the

events module so require events here

when we call the require function we get

the event emitter class so constant

event emitter note that here in terms of

the naming the first letter of every

word is uppercase this is the convention

that indicates that this event emitter

is a class it's not a function it's not

a simple value it's a class a class is

container for properties and functions

which we call methods so in this event

we have these metals that you see here

in the documentat­ion so a class is a

container for a bunch of related methods

and properties now here in order to use

this event emitter first we need to

create an instance of this class so

constant emitter we set this to new

event emitter so here this emitter is an

object in case you don't know the

difference between a class and an object

let me give you a metaphor a class is

like human and an object is like an

actual person like John Mary and so on

so a class defines the properties and

behavior of a concept like a human but

an object is an actual instance of that

class okay so here this first event

emitter is a class it's a blueprint it

defines what an event emitter can do but

this second emitter is an actual object

this is the one that we're going to use

in our applicatio­n so this emitter has a

bunch of methods look these are all the

metals that you saw in the documentat­ion

now even though here we have more than

ten metals most of the time we use only

two of these methods one is emit that we

use to raise an event the first time I

saw this method it didn't make sense to

me because English is my second language

and I didn't know what emit means so if

you're in the same boat ma it basically

means making a noise or produce

something in this case you're making a

noise in your applicatio­n you're

signaling that an event has happened

okay so that's the meaning of Emmet and

here we pass an argument that is the

name of the event let's say message

in the future we're going to extend our

lager module and every time we log a

message we're going to raise an event

called message locked okay now if you

run this applicatio­n nothing is going to

happen let me show you back in the

terminal node app J gasps look nothing

happened because we have raised an event

here but nowhere in our applicatio­n we

have registered a listener that is

interested in that event a listener is a

function that will be called when that

okay so let's register a listener that

will be called when the message log

event is raised so register a listener

so emitter dot look here we have this

method add listener but we have an alias

for this that we use more often that is

on if you're worked with jQuery you have

so on or add listener they're exactly

the same but quit often reused on method

now this method takes two arguments the

first one is the name of the event in

this case message locked and the second

one is a callback function or the actual

listener so here we pass a function and

this function will be called when that

event is raised okay now for now I just

want to lock a message in the console so

console let's say listener called like

this now let's run this applicatio­n so

node FJ guess and we got this message

listener call so this indicates that

function or listener was called okay and

of course the order is important here if

you register this listener after calling

the Amit method nothing would have

happened because when we call the Amit

method this eMeter iterates over all the

registered listeners and calls them

synchronou­sly okay so this is the basic

of raising events and handling them

using the eve an emitter class

now quite often when you want to raise

an event we also want to send some data

about that event for example in our

lager module when we log a message

perhaps our remote login service will

generate an ID for that message perhaps

we want to return that ID to the client

or it may give us a URL to access that

log message directly so here when

raising an event we can add additional

arguments which we refer to as event

arguments so we can add an ID like one

and we can add a URL but as you can see

these magic values here are a little bit

confusing if you want to send multiple

values about an event it's a better

practice to encapsulat­e those values

inside an object so here we have an

object we give it a couple of properties

like ID we set it to ID of this message

that is logged and another property URL

like this okay so we're referring to

this object as event argument now when

registerin­g a listener here this

callback function this actual listener

can also receive this event argument so

here we add a parameter called arc we

can call it anything the name doesn't

but by convention we often use arc or

some people use e to refer to the event

or event arc whatever you prefer is

perfectly fine so here we have arc now

let's log in on the console very simple

let's run this applicatio­n so note okay

look listen are called and here's our

event arc and with this technique we can

pass data about the event that just

now one last thing to make this code a

little bit simpler in es6 or equal

script six we have this feature called

arrow function with an arrow function we

can get rid of this function keyword so

here we have the arguments and after

that we have the body of that function

now to separate the two we use an arrow

and that's why we call this arrow

function you can see this syntax is a

little bit simpler and a lot of people

prefer to use arrow functions in es6 now

here's a simple exercise for you let's

imagine in our lager module just before

calling our remote service to log the

message we're going to raise an event

called logging and while raising this

event we also want to send some data

that is the message that we're going to

lock so what I want you to do is to use

what you have learned in this lecture

and raise and handle is logging event

it's a very simple exercise I just want

you to get used to this syntax

now in the real world is quite rare that

you would work with this event emitter

object directly instead you want to

create a class that has all the

capabiliti­es of the event emitter and

then you will use that class in your

code let me explain what I mean by that

and why so let's open up our lager

module so in this module we're exporting

a simple function log right and here we

log that message on the console now

after this we want to raise an event and

then later in app module we will listen

for that event and do something so let's

go back to our app module and copy some

code into the lager module so on the top

I'm gonna copy these two lines to bring

the event emitter in this module okay

now back in app module I'm also gonna

move these two lines for raising an

event into the lager module because this

code should not be here it's the lager

module that emits or signals an event

saying the message is locked so cut so

here after we log the message you raise

now back in app module we don't need

this comment here we need to load the

lager module and call the log function

so constant log we call the require

function and set the path to the lager

module and here we simply call the log

function with a message okay now when we

run this applicatio­n we are only going

to see this message on the console in

other words this event listener will not

be caught let's verify that and then I

so back in terminal node app J s look we

only got the message on the console so

our event listener was not caught the

reason for this is because here we're

working with two different event

emitters in app j/s we have this even

emitter object and in longer module we

have another event emitter object so

earlier I told you that a class is like

a blueprint and an object is an actual

instance as a metaphor I said we could

human or person but the objects could be

Jack John Mary Bob whatever so in this

case we have two different objects in

the logger module you're using this

emitter object to emit an event whereas

in app module we're using another event

emitter object to handle that event

these are completely different so when

we register a listener here that

listener is only registered with this

event emitter which is completely

different from the other event emitter

so that's why I told you in your

applicatio­ns it's very rare that you

would want to work with this event

emitter directly instead you want to

create a class that has all the

capabiliti­es of this event emitter but

it has additional capabiliti­es in this

case we want to create a class called

logger that has this additional method

lock okay so the first thing you want to

do here is to define a class in es6 we

have this keyword class which is a

syntactica­l sugar for creating a

constructo­r function with this we can

define a class logger note that the

first letter of every word in a class

should be uppercase this is the Pascal

case convention that we use for naming

classes so class logger we have a code

block now we need to move this log

function inside this logger class so cut

paste it here now we have an error

because when we define a function inside

a class we don't need this function

keyword and from now on we refer to this

function as a method so when a function

is inside a class we say that's a method

in that class okay so here we have this

I'm exporting the log function we're

going to export the logger class okay

now we want this logger class to have

all the capabiliti­es of this event

emitter the way we do that is by using

the extends keyword that comes in es6 so

extends and here we add the name of the

parent or the base class so event

emitter and with this simple change this

logger class will have all the

functional­ity that is defined in event

emitter so here when raising this event

instead of using this emitter object

we're going to use this so in this class

we can directly omit or raise events

okay and now we no longer need this

actual emitter object because we have

not used it anywhere in this code so

delete we're done with the logger module

so here when requiring the logger module

we get a class so I'm gonna rename this

to lager with capital L that's a class

now we create an object so new lager

and then to log a message recall logger

deadlock now similar to the change that

we made in the logger module we no

longer need this event a meter object

here we want to work directly with this

logger object so we're gonna register

this listener on this logger object okay

so I'm gonna move this code after

creating the logger we say hey logger

when you raise this message log event I

want to execute this code okay and

finally you can see we no longer need

this event emitter object it's not used

anywhere delete now when you run this

applicatio­n we're going to see this

message on the console but also because

we're using the same logger object for

registerin­g an event listener and also

raising an event we're going to see this

message on the console so note fjs look

this is the message on the console and

successful­ly caught so let's quickly

recap if you want to raise events in

your applicatio­n to signal that

something has happened you need to

create a class that extend event emitter

with this that class will have all the

functional­ity defined in event emitter

but you can also add additional

functional­ity in this case we have the

ability to log a message and then inside

that class whenever you want to raise an

event you use this that emit because

this references this longer class itself

which extends event emitter so all the

methods defined an event emitter will

also be part of this class okay and

finally in app module again instead of

using an instance of event emitter you

will use an instance of the custom class

that you have defined that extends event

one of the powerful building blocks of

node is the HTTP module that we use for

creating networking applicatio­ns for

example we can create a web server that

listens for HTTP requests on a given

port and with this we can easily create

a back-end service for our client

applicatio­ns like a web applicatio­n that

we build with react or angular or a

mobile applicatio­n running on a mobile

device so once again back in the note

documentat­ion in the list of modules we

can find this HTTP module in this module

you can see various classes like HTTP

that agent HTTP that client requests and

so on each of this classes has a bunch

of properties methods and events so back

in vs code let's load the HTTP module so

constant HTTP we set it to require HTTP

okay now here we can call HTTP dot

create server this is one of the

functions defined in this module and

with this we can create a web server so

let's store the result in a server

object now what is interestin­g is that

this server is an event emitter so it

has all the capabiliti­es of event

emitter that you saw earlier in this

section so look server dot we have the

on method or add listener or omit and so

on also if you look at the documentat­ion

for the HTTP module on this page you can

see HTTP that's server class here the

documentat­ion says that this class

inherits from net dot server so this is

another class defined in the net module

let's have a look now here the

documentat­ion says that net the server

is an event emitter so that's why I said

a bunch of notes core functional­ity is

based on if an emitter so back to our

server object now we can call server

and give it a port let's say port 3000

now following that I'm gonna add a

console deadlock saying listening on

port 3000 okay now when we run this

applicatio­n this server will listen on

port 3000 as I told you before every

time there is a new connection or new

request this server raises an event so

we can use the own method to handle that

event so before listening we want to

register a listener or a handler so

server dot on the name of the event is

connection then you can find in the

documentat­ion so you don't have to

memorize any of these stuff okay and the

second argument is a callback function

or the actual listener as you can see in

the tooltip here this listener is a

function with one argument that is

socket of type socket class and it

returns void so here we have the arrow

function syntax in es6 so let's add an

error function that takes a socket and

goes to this code block now here we can

simply log something on the console new

connection now back in the terminal

let's run this applicatio­n we can see we

now back in the browser let's head over

to localhost port 3000 and now if you

look in the terminal you can see we have

a new connection here so you can see

this server object raises different

kinds of events that you can respond to

now in real world applicatio­ns we are

not going to respond to the connection

event to build an HTTP service this is

very low level so let's delete this what

we commonly do is we pass a callback

function to this create server method so

function this function takes two

parameters request and response or we

can use the error function syntax so we

remove the function keyword and add this

fat arrow here now in this function

instead of working with a socket we can

work with the actual request or response

objects so we can check if request that

URL equals slash then we can send

something to the client for example

response dot write hello world and then

we end the response okay now back in the

terminal we can exit here by pressing

ctrl + C and then run the applicatio­n

again okay we're still listening on port

3000 let's refresh this page so we got

hello world on home page now if you want

to build a back-end service for our web

or mobile applicatio­ns we need to handle

various routes here for example we can

have another if block if requested URL

equals slash API slash courses

perhaps here we want to return the list

of courses from the database so we would

do something like this response dot

right here we want to return an array of

objects using JSON so we use JSON dot

stringify and give it an array of

objects now for simplicity here we don't

the database or complex objects let's

just return an array of numbers 1 2 & 3

so we pass this to json stringify which

will convert this array into a string

using json syntax and then we'll write

it to the response and finally response

the end now back in the terminal we need

to stop this process again and run it

one more time now in the future I will

show you how we can automate this so

every time we make a simple change to

our applicatio­n we don't have to restart

it so now back in the browser if we go

to slash API slash courses we get an

array with three numbers so as you see

building a web server we know it is very

easy now in the real world we are not

going to use this HTTP module to build a

back-end service for our applicatio­n the

reason for this is because as you can

see here as we add more routes this code

gets more complex because we add all of

them in a linear way inside this

callback function so instead we use a

framework called Express which gives our

applicatio­n a clean structure to handle

various routes internally the Express

framework is built on top of the HTTP

   

↑ Return to Top ↑