Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
In this video, we'll take a look at the Node.js website and see how we can create our own server.
Node.js APIs Used
Killing processes
First find the process.
$ ps -aux
Second kill the process.
$ kill -9 <process id/PID from ps>
Using -9 sends a signal to the process to kill immediately. It can't be ignored by the process and the process can't do any clean up. Use wisely. You can read more here.
Leet Speak
Leet speak is used in "hacking" or programming circles where letters are substituted with numbers. The term leet comes from the word elite and can be written as l33t or 1337. Sometimes in code samples you may see 1337 being used.
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
The first step in our planning was to
create a web server.
0:00
That is, something that listens to
requests from clients like a web browser.
0:03
Let's go to the node.js website and
0:07
see what it has to say about creating web
servers.
0:09
If you go to nodejs.org you'll see we've
got the home,
0:12
downloads, docs, community, about, jobs,
and blog.
0:17
But, also, on this homepage we can install
on our local machine.
0:20
But they give us some examples of node.js
code.
0:24
So here's an example of a web server,
which is what we wanna build.
0:28
So it goes var, http, require http.
0:32
Cool.
0:36
Then it creates server.
0:36
With a callback, with a req and a res,
which means request and response.
0:38
And it writes 200, which is the status
code saying everything's okay.
0:45
And it prints out text.
0:51
Hello world.
0:54
So this is end, this is the, the response
is end.
0:55
And it listens on port 1337 or leet.
0:59
[LAUGH] And listens on the IP address
127.0.0.1.
1:05
Which is your local machine if you're on a
local machine.
1:14
And it prints out a log.
1:17
So, let's just copy and paste this into
our application.
1:19
So underneath where we said to create a
web server let's paste this.
1:25
And let's update the code so it doesn't
say res and req.
1:32
So let's do request and response so
1:38
it's absolutely clear what we're
programming here.
1:43
Cuz it's not that obvious when it's in
that short hand.
1:48
Now in order for this to work in
workspaces,
1:55
if you look up here on the right hand side
we've got different port numbers.
1:58
And those are just basically what the
server listens on to the outside world.
2:02
So instead of having 1337, we can pick any
one of these numbers here,
2:09
so we can pick 3000 for example.
2:15
[BLANK_AUDIO]
2:17
And because workspaces isn't our local
machine,
2:21
it's a machine on the Internet with its
own IP address.
2:24
We can just, actually, remove this
parameter here, and
2:28
it will just listen, naturally, to the,
the world out there.
2:32
And we can do, instead of this,
2:38
we'll just write workspace url, just as a
placehold.
2:41
It's, it doesn't do anything, it's just
for our benefit when we run the survey it
2:49
shows that we've started running it, it's
just a console.log, it's nothing magic.
2:54
So, if we do show console and
2:59
then node app.js,
3:03
we can see the server's running at the
workspace-url,
3:10
and when we go to port 3000, it goes hello
world.
3:14
So this is the URL here.
3:18
Normally when you're on your local machine
you'd do something like localhost:3000,
3:22
but because we're in workspaces theres a
special
3:28
url that gets generated, and it says port
3000 at the beginning.
3:33
It's just a convention that treehouse
uses,
3:38
it's not anything that you'd do on your
local machine.
3:41
So as we can see Hello World is printing
out, but
3:46
what happens if we go to say /chalkers or
something like that.
3:49
It still says Hello World.
3:55
So every single route we go to it just
prints out that response, Hello World.
3:57
So we'll need to figure out how to handle
different URLs in the future.
4:02
Let's try out writing more than just one
line to the response.
4:06
We can do response.write.
4:11
[BLANK_AUDIO]
4:17
And we can say this is before the end,
4:20
and slash enters the return character and
4:26
afterwards let's do response don't write.
4:32
This is after the end.
4:42
[BLANK_AUDIO]
4:45
So what, what I'm saying by end is in this
method here, this response to end call.
4:50
And let's run this in the console.
4:57
[BLANK_AUDIO]
4:59
App.js, and we've got a problem.
5:04
When we scroll up it says that the listen
address is in use,
5:08
so port 3000 is already being listened to
so.
5:14
What happened is when we closed the
console to get more screen space,
5:17
Node was still running.
5:21
It's still running right now in the
workspace.
5:22
But the problem is is that when we started
up a new console,
5:25
we're trying to bind to that same port.
5:29
We're trying to listen on that same port
3000.
5:31
So we need to kill the process of node.
5:34
Now, if you're not familiar with killing
processes, it's fairly simple.
5:37
What you need to do is figure out what you
need to kill.
5:41
So [LAUGH] you do PS which is for
processes and then just type aux.
5:45
And as you can see here we've got a node
app running, and
5:51
this is the identification number for that
particular app instance running.
5:55
So we can do kill minus nine, four, nine,
six.
5:59
And then it should have killed it.
6:06
So, now we can do node, app.js and it
should run perfectly.
6:09
So, be mindful that you can kill the
server by just putting Ctrl+C twice.
6:15
And it will, you can boot it up again like
that, or
6:23
you'd have to go through the process where
you do ps minus aux and
6:28
then find the process ID and then kill
that process.
6:32
So let's go to here and it says this is
before the end.
6:36
Hello world.
6:42
And we don't see this is after the end.
6:42
That's because, when we call the end, we
can't write to the response anymore.
6:45
The end says it's done.
6:50
The response is over from the server,
6:52
so the browser isn't gonna be listening to
anything coming from the server anymore.
6:54
So, let's try something else out.
7:00
We can do a set interval.
7:02
And setInterval is a way for doing
something every so many milliseconds.
7:09
So we can do something like print
7:14
the dates of the response, of the day time
every one second.
7:19
So in milliseconds that's 1,000.
7:23
Milliseconds per second, and we can write.
7:26
I'm just going to terminate this node
instance by doing Cmd+C, click on x.
7:32
Sorry, not Cmd+C, Ctrl+C.
7:39
And then let's write new date.
7:43
And we can add that to the return counter
so
7:53
we'll see the date get printed out on
every single line.
7:56
Let's get rid of this after response.
8:01
[BLANK_AUDIO]
8:03
And do response to end and see what
happens.
8:06
[BLANK_AUDIO]
8:09
Node.
8:16
So let's type node app.js.
8:18
Click on preview.
8:26
And it just says hello world.
8:28
What, what happened there?
8:29
Well, set interval actually executes
after that first second so
8:34
this callback got called after this line
of code got executed,
8:38
so the callback gets executed one second
after this gets run.
8:44
So, it doesn't go to the response.
8:50
So lets get rid of the end of the
response, hello world, and
8:52
just see what's happens when we just run
the set interval.
8:56
[BLANK_AUDIO]
9:00
So, it took about 20 seconds or so for
this to show up on the page
9:10
because Chrome expects that a web page is
being delivered.
9:16
Like the header, the body,
9:21
the footer, all those types of things are
going to be delivered.
9:24
But because we're not actually ending the
response,
9:29
it waited 20 seconds before attempting to
render it.
9:31
Because it felt like, oh maybe we'll get
all this information together and
9:35
we can render the HTML, or what have you.
9:39
So, Chrome waited for a while, expecting
that the file
9:43
that it's downloading is HTML or text or
what have you.
9:49
It expected that it have an end, but
9:54
because we didn't specify an end, it gave
up after 20 seconds or so,
9:57
and then it starts printing out the time
every one second.
10:02
So this is a kind of a powerful thing that
node can do is it,
10:07
it can literally create a connection and
keep it open and keep sending data down.
10:11
And for some applications that's really
good and which,
10:16
which we won't cover in this course, but
we'll cover in a future time.
10:20
So let's just kill that instance by doing
Cmd Ctrl+C.
10:25
And in the next video we'll figure out how
to handle multiple roots,
10:32
because we're doing the same thing in all
the different roots right now.
10:36
Experiencing JavaScript's asynchronous
nature in the context of creating
10:41
a web server response provided us with a
very important learning opportunity
10:45
that once the end method is called on the
response,
10:50
you can't add additional data to the
response.
10:53
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up