Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Branch: master
Fetching contributors…

Cannot retrieve contributors at this time

3834 lines (3428 sloc) 246.708 kB
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The Node Beginner Book » A comprehensive Node.js tutorial</title>
<meta name="description" content="A comprehensive Node.js tutorial for beginners: Learn how to build a full blown web application with server-side JavaScript" />
<link rel="icon" href="favicon.png" type="image/png" />
<link rel="stylesheet" type="text/css" href="default.css" />
</head>
<body>
<div id="forkmeongithub">
<a href="https://github.com/ManuelKiessling/NodeBeginnerBook"><img src="fork_me_on_github.png" width="149" height="149" alt="Fork me on GitHub" /></a>
</div>
<div id="ibookstore-banner">
<a href="buy-ibook/index.html"><img src="ibookstore-banner.jpg" width="100%" /></a>
</div>
<div id="translations">
<table>
<tr>
<td>
<a href="index-jp.html">
<div class="flag"><img src="jp-flag.png" width="24" height="24" alt="japanese flag" /></div>
<div class="text">日本語で読む</div>
</a>
</td>
<td>
<a href="index-es.html">
<div class="flag"><img src="es-flag.png" width="24" height="24" alt="spanish flag" /></div>
<div class="text">Lee este tutorial en Español</div>
</a>
</td>
<td>
<a href="index-kr.html">
<div class="flag"><img src="kr-flag.png" width="24" height="24" alt="korean flag" /></div>
<div class="text">이 튜토리얼을 한글로 보세요</div>
</a>
</td>
</tr>
<tr>
<td>
<a href="index-zh-cn.html">
<div class="flag"><img src="cn-flag.png" width="24" height="24" alt="chinese flag" /></div>
<div class="text">阅读本书中文版</div>
</a>
</td>
<td>
<a href="index-zh-tw.html">
<div class="flag"><img src="cn-flag.png" width="24" height="24" alt="chinese flag" /></div>
<div class="text">阅读本书繁体中文版</div>
</a>
</td>
<td>
<a href="http://www.nodebeginner.ru">
<div class="flag"><img src="ru-flag.png" width="24" height="24" alt="russian flag" /></div>
<div class="text">Читать этот учебник на русском</div>
</a>
</td>
</tr>
</table>
</div>
<div class="buybox">
<div class="buy-the-bundle">
<div class="cover">
<p>
The perfect introduction plus the perfect reference in one bundle!
</p>
<a href="buy-bundle/index.html"><img src="the_node_beginner_book_cover_small.png" height="86" width="57" /></a>
<a href="buy-bundle/index.html"><img src="hands-on_node.js_cover.png" height="86" width="57" /></a>
</div>
<div class="description">
<p>
LeanBundle currently offers
the final version of
<br />
<strong>The Node Beginner Book</strong>
<br />
plus Pedro Teixeira's excellent
<br />
<strong>Hands-on Node.js</strong> for only
<br />
<br />
<strong class="price dollarsign">$</strong><strong class="price">9.99</strong>
<br />
(regular price <del>$21.98</del>)
</p>
</div>
<div class="buy">
<p>
226 pages in total
<br />
PDF, ePub & MOBI
<br />
Direct download
<br />
Free updates
</p>
<a class="buttonlink" href="buy-bundle/index.html">
<div class="button">Buy this<br />bundle now</div>
</a>
</div>
</div>
<div class="buy-kindle">
<div class="inner">
<a href="buy-kindle/index.html"><img class="cover" src="the_node_beginner_book_cover_small.png" height="86" width="57" /></a>
<br />
<a href="buy-kindle/reviews.html"><img class="stars" src="amazon_rating_stars.png" width="65" height="12" /></a>
<br />
(<a href="buy-kindle/reviews.html">Read customer reviews</a>)
<br />
<a href="buy-kindle/index.html"><img class="button" src="add_to_kindle_button.png" width="102" height="25"/></a>
</div>
</div>
</div>
<div id="book">
<div>
<h1>The Node Beginner Book</h1>
<div id="author">A Node.js tutorial by <a href="http://twitter.com/manuelkiessling">Manuel Kiessling</a></div>
<div id="social">
<a href="https://twitter.com/share" class="twitter-share-button" data-url="http://www.nodebeginner.org" data-text="The Node Beginner Book » A comprehensive Node.js tutorial:" data-via="manuelkiessling">Tweet</a>
<br />
<g:plusone size="medium"></g:plusone>
</div>
<a name="about"></a>
<h2>About</h2>
<p>
The aim of this document is to get you started with developing
applications with Node.js, teaching you everything you need to
know about "advanced" JavaScript along the way. It goes way
beyond your typical "Hello World" tutorial.
</p>
<a name="status"></a>
<h3>Status</h3>
<p>
You are reading the final version of this book, i.e., updates
are only done to correct errors or to reflect changes in new
versions of Node.js. It was last updated on September 9, 2012.
</p>
<p>
The code samples in this book are tested to work with Node.js
version 0.8.8.
</p>
<a name="intended-audience"></a>
<h3>Intended audience</h3>
<p>
This document will probably fit best for readers that have a
background similar to my own: experienced with at least one
object-oriented language like Ruby, Python, PHP or Java, only little
experience with JavaScript, and completely new to Node.js.
</p>
<p>
Aiming at developers that already have experience with other
programming languages means that this document won't cover
really basic stuff like data types, variables, control structures
and the likes. You already need to know about these to understand
this document.
</p>
<p>
However, because functions and objects in JavaScript are different
from their counterparts in most other languages, these will be
explained in more detail.
</p>
<a name="structure"></a>
<h3>Structure of this document</h3>
<p>
Upon finishing this document, you will have created a complete web
application which allows the users of this application to view web
pages and upload files.
</p>
<p>
Which, of course, is not exactly
world-changing, but we will go some extra miles and not only create
the code that is "just enough" to make these use cases possible,
but create a simple, yet complete framework to cleanly separate the
different aspects of our application. You will see what I mean in a
minute.
</p>
<p>
We will start with looking at how JavaScript development in Node.js
is different from JavaScript development in a browser.
</p>
<p>
Next, we will stay with the good old tradition of writing a "Hello
World" application, which is a most basic Node.js application that
"does" something.
</p>
<p>
Then, we will discuss what kind of "real" application we want to
build, dissect the different parts which need to be implemented to
assemble this application, and start working on each of these parts
step-by-step.
</p>
<p>
As promised, along the way we will learn about some of the more
advanced concepts of JavaScript, how to make use of them, and
look at why it makes sense to use these concepts instead of
those we know from other programming languages.
</p>
<p>
The source code of the finished application is available through
<a href="https://github.com/ManuelKiessling/NodeBeginnerBook/tree/master/code/application">the
NodeBeginnerBook Github repository</a>.
</p>
<div id="table-of-contents-headline">Table of contents</div>
<div id="table-of-contents">
<ul>
<li><a href="#about">About</a>
<ul>
<li><a href="#status">Status</a></li>
<li><a href="#intended-audience">Intended audience</a></li>
<li><a href="#structure">Structure of this document</a></li>
</ul>
</li>
<li><a href="#javascript-and-nodejs">JavaScript and Node.js</a>
<ul>
<li><a href="#javascript-and-you">JavaScript and You</a></li>
<li><a href="#a-word-of-warning">A word of warning</a></li>
<li><a href="#server-side-javascript">Server-side JavaScript</a></li>
<li><a href="#hello-world">"Hello World"</a></li>
</ul>
</li>
<li><a href="#a-full-blown-web-application-with-nodejs">A full blown web application with Node.js</a>
<ul>
<li><a href="#the-use-cases">The use cases</a></li>
<li><a href="#the-application-stack">The application stack</a></li>
</ul>
</li>
<li><a href="#building-the-application-stack">Building the application stack</a>
<ul>
<li><a href="#a-basic-http-server">A basic HTTP server</a></li>
<li><a href="#analyzing-our-http-server">Analyzing our HTTP server</a></li>
<li><a href="#passing-functions-around">Passing functions around</a></li>
<li><a href="#how-function-passing-makes-our-http-server-work">How function passing makes our
HTTP server work</a></li>
<li><a href="#event-driven-callbacks">Event-driven asynchronous callbacks</a></li>
<li><a href="#how-our-server-handles-requests">How our server handles requests</a></li>
<li><a href="#finding-a-place-for-our-server-module">Finding a place for our server module</a>
</li>
<li><a href="#whats-needed-to-route-requests">What's needed to "route" requests?</a></li>
<li><a href="#execution-in-the-kongdom-of-verbs">Execution in the kingdom of verbs</a></li>
<li><a href="#routing-to-real-request-handlers">Routing to real request handlers</a></li>
<li><a href="#making-the-request-handlers-respond">Making the request handlers respond</a>
<ul>
<li><a href="#how-to-not-do-it">How to not do it</a></li>
<li><a href="#blocking-and-non-blocking">Blocking and non-blocking</a></li>
<li><a href="#responding-request-handlers-with-non-blocking-operations">Responding
request handlers with non-blocking operations</a>
</li>
</ul>
</li>
<li><a href="#serving-something-useful">Serving something useful</a>
<ul>
<li><a href="#handling-post-requests">Handling POST requests</a></li>
<li><a href="#handling-file-uploads">Handling file uploads</a></li>
</ul>
</li>
<li><a href="#conclusion-and-outlook">Conclusion and outlook</a></li>
</ul>
</li>
</ul>
</div>
<a name="javascript-and-nodejs"></a>
<h2>JavaScript and Node.js</h2>
<a name="javascript-and-you"></a>
<h3>JavaScript and You</h3>
<p>
Before we talk about all the technical stuff, let's take a
moment and talk about you and your relationship with
JavaScript. This chapter is here to allow you to estimate
if reading this document any further makes sense for you.
</p>
<p>
If you are like me, you started with HTML "development"
long ago, by writing HTML documents. You came along this
funny thing called JavaScript, but you only used it in a
very basic way, adding interactivity to your web pages
every now and then.
</p>
<p>
What you really wanted was "the real thing", you wanted to
know how to build complex web sites - you learned a
programming language like PHP, Ruby, Java, and started
writing "backend" code.
</p>
<p>
Nevertheless, you kept an eye on JavaScript, you saw that
with the introduction of jQuery, Prototype and the likes,
things got more advanced in JavaScript land, and that this
language really was about more than <em>window.open()</em>.
</p>
<p>
However, this was all still frontend stuff, and although it
was nice to have jQuery at your disposal whenever you felt
like spicing up a web page, at the end of the day you were,
at best, a JavaScript <em>user</em>, but not a JavaScript
<em>developer</em>.
</p>
<p>
And then came Node.js. JavaScript on the server, how cool
is that?
</p>
<p>
You decided that it's about time to check out the old, new
JavaScript. But wait, writing Node.js applications is the
one thing; understanding why they need to be written the
way they are written means - understanding JavaScript.
And this time for real.
</p>
<p>
Here is the problem: Because JavaScript really lives two,
maybe even three lives (the funny little DHTML helper from
the mid-90's, the more serious frontend stuff like jQuery
and the likes, and now server-side), it's not that easy to
find information that helps you to learn JavaScript the
"right" way, in order to write Node.js applications in a
fashion that makes you feel you are not just using
JavaScript, you are actually developing it.
</p>
<p>
Because that's the catch: you already are an experienced
developer, you don't want to learn a new technique by just
hacking around and mis-using it; you want to be sure that
you are approaching it from the right angle.
</p>
<p>
There is, of course, excellent documentation out there.
But documentation alone sometimes isn't enough. What is
needed is guidance.
</p>
<p>
My goal is to provide a guide for you.
</p>
<a name="a-word-of-warning"></a>
<h3>A word of warning</h3>
<p>
There are some really excellent JavaScript people out
there. I'm not one of them.
</p>
<p>
I'm really just the guy I talked about in the previous
paragraph. I know a thing or two about developing backend
web applications, but I'm still new to "real" JavaScript
and still new to Node.js. I learned some of the more
advanced aspects of JavaScript just recently.
I'm not experienced.
</p>
<p>
Which is why this is no "from novice to expert" book. It's
more like "from novice to advanced novice".
</p>
<p>
If I don't fail, then this will be the kind of
document I wish I had when starting with Node.js.
</p>
<a name="server-side-javascript"></a>
<h3>Server-side JavaScript</h3>
<p>
The first incarnations of JavaScript lived in browsers.
But this is just the context. It defines what you can
do with the language, but it doesn't say much about what
the language itself can do. JavaScript is a "complete"
language: you can use it in many contexts and achieve
everything with it you can achieve with any other
"complete" language.
</p>
<p>
Node.js really is just another context: it allows you to run
JavaScript code in the backend, outside a browser.
</p>
<p>
In order to execute the JavaScript you intend to run in the
backend, it needs to be interpreted and, well, executed.
This is what Node.js does, by making use of Google's V8 VM, the
same runtime environment for JavaScript that Google
Chrome uses.
</p>
<p>
Plus, Node.js ships with a lot of useful modules, so you don't
have to write everything from scratch, like for example
something that outputs a string on the console.
</p>
<p>
Thus, Node.js is really two things: a runtime environment and a
library.
</p>
<p>
In order to make use of these, you need to install Node.js.
Instead of repeating the process here, I kindly ask you to
visit
<a href="https://github.com/joyent/node/wiki/Installation" title="Building and Installing Node.js">the
official
installation instructions</a>. Please come back once you
are up and running.
</p>
<a name="hello-world"></a>
<h3>"Hello World"</h3>
<p>
Ok, let's just jump in the cold water and write our first
Node.js application: "Hello World".
</p>
<p>
Open your favorite editor and create a file called
<em>helloworld.js</em>. We want it to write "Hello World"
to STDOUT, and here is the code needed to do that:
</p>
<pre class="prettyprint lang-js"><span class="pln">console</span><span class="pun">.</span><span
class="pln">log</span><span class="pun">(</span><span class="str">"Hello World"</span><span class="pun">);</span></pre>
<p>
Save the file, and execute it through Node.js:
</p>
<pre>node helloworld.js</pre>
<p>
This should output <em>Hello World</em> on your terminal.
</p>
<p>
Ok, this stuff is boring, right? Let's write some real
stuff.
</p>
<a name="a-full-blown-web-application-with-nodejs"></a>
<h2>A full blown web application with Node.js</h2>
<a name="the-use-cases"></a>
<h3>The use cases</h3>
<p>
Let's keep it simple, but realistic:
</p>
<ul>
<li>
The user should be able to use our application with
a web browser
</li>
<li>
The user should see a welcome page when
requesting http://<em>domain</em>/start which displays a
file upload form
</li>
<li>
By choosing an image file to upload and submitting the
form, this image should then be uploaded to
http://<em>domain</em>/upload, where it is displayed once
the upload is finished
</li>
</ul>
<p>
Fair enough. Now, you could achieve this goal by googling
and hacking together <em>something</em>. But that's not
what we want to do here.
</p>
<p>
Furthermore, we don't want to write only the most basic
code to achieve the goal, however elegant and correct this code
might be. We will intentionally add more abstraction than
necessary in order to get a feeling for building more
complex Node.js applications.
</p>
<a name="the-application-stack"></a>
<h3>The application stack</h3>
<p>
Let's dissect our application. Which parts need to be
implemented in order to fulfill the use cases?
</p>
<ul>
<li>
We want to serve web pages, therefore we need an
<strong>HTTP server</strong>
</li>
<li>
Our server will need to answer differently to
requests, depending on which URL the request was
asking for, thus we need some kind of
<strong>router</strong> in order to map requests
to request handlers
</li>
<li>
To fullfill the requests that arrived at the server
and have been routed using the router, we need
actual <strong>request handlers</strong>
</li>
<li>
The router probably should also treat any incoming
POST data and give it to the request handlers in
a convenient form, thus we need <strong>request
data handling</strong>
</li>
<li>
We not only want to handle requests for URLs, we
also want to display content when these URLs are
requested, which means we need some kind of
<strong>view logic</strong> the request handlers
can use in order to send content to the user's
browser
</li>
<li>
Last but not least, the user will be able to upload
images, so we are going to need some kind of
<strong>upload handling</strong> which takes care of
the details
</li>
</ul>
<p>
Let's think a moment about how we would build this stack
with PHP. It's not exactly a secret that the typical setup
would be an Apache HTTP server with mod_php5 installed.
<br>
Which in turn means that the whole "we need to be able to
serve web pages and receive HTTP requests" stuff doesn't
happen within PHP itself.
</p>
<p>
Well, with node, things are a bit different. Because with
Node.js, we not only implement our application, we also
implement the whole HTTP server. In fact, our web
application and its web server are basically the same.
</p>
<p>
This might sound like a lot of work, but we will see in a
moment that with Node.js, it's not.
</p>
<p>
Let's just start at the beginning and implement the first
part of our stack, the HTTP server.
</p>
<a name="building-the-application-stack"></a>
<h2>Building the application stack</h2>
<a name="a-basic-http-server"></a>
<h3>A basic HTTP server</h3>
<p>
When I arrived at the point where I wanted to start with my
first "real" Node.js application, I wondered not only how to
actually code it, but also how to organize my code.
<br>
Do I need to have everything in one file? Most tutorials on
the web that teach you how to write a basic HTTP server in
Node.js have all the logic in one place. What if I want to
make sure that my code stays readable the more stuff I
implement?
</p>
<p>
Turns out, it's relatively easy to keep the different
concerns of your code separated, by putting them in
modules.
</p>
<p>
This allows you to have a clean main file, which you
execute with Node.js, and clean modules that can be used by
the main file and among each other.
</p>
<p>
So, let's create a main file which we use to start our
application, and a module file where our HTTP server code
lives.
</p>
<p>
My impression is that it's more or less a standard to name
your main file <em>index.js</em>. It makes sense to put our
server module into a file named <em>server.js</em>.
</p>
<p>
Let's start with the server module. Create the file
<em>server.js</em> in the root directory of your project,
and fill it with the following code:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> http </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br><br>http</span><span
class="pun">.</span><span class="pln">createServer</span><span class="pun">(</span><span class="kwd">function</span><span
class="pun">(</span><span class="pln">request</span><span class="pun">,</span><span class="pln"> response</span><span
class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; response</span><span
class="pun">.</span><span class="pln">writeHead</span><span class="pun">(</span><span
class="lit">200</span><span class="pun">,</span><span class="pln"> </span><span
class="pun">{</span><span class="str">"Content-Type"</span><span class="pun">:</span><span
class="pln"> </span><span class="str">"text/plain"</span><span class="pun">});</span><span
class="pln"><br>&nbsp; response</span><span class="pun">.</span><span class="pln">write</span><span
class="pun">(</span><span class="str">"Hello World"</span><span class="pun">);</span><span
class="pln"><br>&nbsp; response</span><span class="pun">.</span><span class="pln">end</span><span
class="pun">();</span><span class="pln"><br></span><span class="pun">}).</span><span
class="pln">listen</span><span class="pun">(</span><span class="lit">8888</span><span
class="pun">);</span></pre>
<p>
That's it! You just wrote a working HTTP server. Let's
prove it by running and testing it. First, execute your
script with Node.js:
</p>
<pre>node server.js</pre>
<p>
Now, open your browser and point it at
<a href="http://localhost:8888/" rel="nofollow">http://localhost:8888/</a>.
This should display a web page that says "Hello World".
</p>
<p>
That's quite interesting, isn't it. How about talking about
what's going on here and leaving the question of how to
organize our project for later? I promise we'll get back to
it.
</p>
<a name="analyzing-our-http-server"></a>
<h3>Analyzing our HTTP server</h3>
<p>
Well, then, let's analyze what's actually going on here.
</p>
<p>
The first line <em>require</em>s the <em>http</em> module
that ships with Node.js and makes it accessible through the
variable <em>http</em>.
</p>
<p>
We then call one of the functions the http module offers:
<em>createServer</em>. This function returns an object, and
this object has a method named <em>listen</em>, and takes
a numeric value which indicates the port number our HTTP
server is going to listen on.
</p>
<p>
Please ignore for a second the function definition that
follows the opening bracket of <em>http.createServer</em>.
</p>
<p>
We could have written the code that starts our server and
makes it listen at port 8888 like this:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> http </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br><br></span><span class="kwd">var</span><span
class="pln"> server </span><span class="pun">=</span><span class="pln"> http</span><span
class="pun">.</span><span class="pln">createServer</span><span class="pun">();</span><span
class="pln"><br>server</span><span class="pun">.</span><span class="pln">listen</span><span class="pun">(</span><span
class="lit">8888</span><span class="pun">);</span></pre>
<p>
That would start an HTTP server listening at port 8888
and doing nothing else (not even answering any incoming
requests).
</p>
<p>
The really interesting (and, if your background is a more
conservative language like PHP, odd looking) part is the
function definition right there where you would expect the
first parameter of the <em>createServer()</em> call.
</p>
<p>
Turns out, this function definition IS the first (and only)
parameter we are giving to the <em>createServer()</em>
call. Because in JavaScript, functions can be passed around
like any other value.
</p>
<a name="passing-functions-around"></a>
<h3>Passing functions around</h3>
<p>
You can, for example, do something like this:
</p>
<pre class="prettyprint lang-js"><span class="kwd">function</span><span class="pln"> say</span><span
class="pun">(</span><span class="pln">word</span><span class="pun">)</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span
class="pln">word</span><span class="pun">);</span><span class="pln"><br></span><span
class="pun">}</span><span class="pln"><br><br></span><span class="kwd">function</span><span class="pln"> execute</span><span
class="pun">(</span><span class="pln">someFunction</span><span class="pun">,</span><span class="pln"> value</span><span
class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; someFunction</span><span
class="pun">(</span><span class="pln">value</span><span class="pun">);</span><span
class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>execute</span><span
class="pun">(</span><span class="pln">say</span><span class="pun">,</span><span
class="pln"> </span><span class="str">"Hello"</span><span class="pun">);</span></pre>
<p>
Read this carefully! What we are doing here is, we pass the
function <em>say</em> as the first parameter to the
<em>execute</em> function. Not the return value of
<em>say</em>, but <em>say</em> itself!
</p>
<p>
Thus, <em>say</em> becomes the local variable
<em>someFunction</em> within <em>execute</em>, and execute
can call the function in this variable by issuing
<em>someFunction()</em> (adding brackets).
</p>
<p>
Of course, because <em>say</em> takes one parameter,
<em>execute</em> can pass such a parameter when calling
<em>someFunction</em>.
</p>
<p>
We can, as we just did, pass a function as a parameter to
another function by its name. But we don't have to take this
indirection of first defining, then passing it - we can
define and pass a function as a parameter to another
function in-place:
</p>
<pre class="prettyprint lang-js"><span class="kwd">function</span><span class="pln"> execute</span><span
class="pun">(</span><span class="pln">someFunction</span><span class="pun">,</span><span class="pln"> value</span><span
class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; someFunction</span><span
class="pun">(</span><span class="pln">value</span><span class="pun">);</span><span
class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>execute</span><span
class="pun">(</span><span class="kwd">function</span><span class="pun">(</span><span
class="pln">word</span><span class="pun">){</span><span class="pln"> console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span
class="pln">word</span><span class="pun">)</span><span class="pln"> </span><span
class="pun">},</span><span class="pln"> </span><span class="str">"Hello"</span><span
class="pun">);</span></pre>
<p>
We define the function we want to pass to <em>execute</em>
right there at the place where <em>execute</em> expects its
first parameter.
</p>
<p>
This way, we don't even need to give the function a name,
which is why this is called an <em>anonymous function</em>.
</p>
<p>
This is a first glimpse at what I like to call "advanced"
JavaScript, but let's take it step by step. For now, let's
just accept that in JavaScript, we can pass a function as
a parameter when calling another function. We can do this
by assigning our function to a variable, which we then
pass, or by defining the function to pass in-place.
</p>
<a name="how-function-passing-makes-our-http-server-work"></a>
<h3>How function passing makes our HTTP server work</h3>
<p>
With this knowledge, let's get back to our minimalistic
HTTP server:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> http </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br><br>http</span><span
class="pun">.</span><span class="pln">createServer</span><span class="pun">(</span><span class="kwd">function</span><span
class="pun">(</span><span class="pln">request</span><span class="pun">,</span><span class="pln"> response</span><span
class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; response</span><span
class="pun">.</span><span class="pln">writeHead</span><span class="pun">(</span><span
class="lit">200</span><span class="pun">,</span><span class="pln"> </span><span
class="pun">{</span><span class="str">"Content-Type"</span><span class="pun">:</span><span
class="pln"> </span><span class="str">"text/plain"</span><span class="pun">});</span><span
class="pln"><br>&nbsp; response</span><span class="pun">.</span><span class="pln">write</span><span
class="pun">(</span><span class="str">"Hello World"</span><span class="pun">);</span><span
class="pln"><br>&nbsp; response</span><span class="pun">.</span><span class="pln">end</span><span
class="pun">();</span><span class="pln"><br></span><span class="pun">}).</span><span
class="pln">listen</span><span class="pun">(</span><span class="lit">8888</span><span
class="pun">);</span></pre>
<p>
By now it should be clear what we are actually doing here:
we pass the <em>createServer</em> function an anonymous
function.
</p>
<p>
We could achieve the same by refactoring our code to:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> http </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br><br></span><span class="kwd">function</span><span
class="pln"> onRequest</span><span class="pun">(</span><span class="pln">request</span><span
class="pun">,</span><span class="pln"> response</span><span class="pun">)</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; response</span><span
class="pun">.</span><span class="pln">writeHead</span><span class="pun">(</span><span
class="lit">200</span><span class="pun">,</span><span class="pln"> </span><span
class="pun">{</span><span class="str">"Content-Type"</span><span class="pun">:</span><span
class="pln"> </span><span class="str">"text/plain"</span><span class="pun">});</span><span
class="pln"><br>&nbsp; response</span><span class="pun">.</span><span class="pln">write</span><span
class="pun">(</span><span class="str">"Hello World"</span><span class="pun">);</span><span
class="pln"><br>&nbsp; response</span><span class="pun">.</span><span class="pln">end</span><span
class="pun">();</span><span class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>http</span><span
class="pun">.</span><span class="pln">createServer</span><span class="pun">(</span><span class="pln">onRequest</span><span
class="pun">).</span><span class="pln">listen</span><span class="pun">(</span><span
class="lit">8888</span><span class="pun">);</span></pre>
<p>
Maybe now is a good moment to ask: Why are we doing it
that way?
</p>
<a name="event-driven-callbacks"></a>
<h3>Event-driven asynchronous callbacks</h3>
<p>
To understand why Node.js applications have to be written this way,
we need to understand how Node.js executes our code. Node's
approach isn't unique, but the underlying execution model is
different from runtime environments like Python, Ruby, PHP or Java.
</p>
<p>
Let's take a very simple piece of code like this:
</p>
<pre class="prettyprint lang-js">var result = database.query("SELECT * FROM hugetable");
console.log("Hello World");</pre>
<p>
Please ignore for now that we haven't actually talked about
connecting to databases before - it's just an example. The
first line queries a database for lots of rows, the second
line puts "Hello World" to the console.
</p>
<p>
Let's assume that the database query is really slow, that it has
to read an awful lot of rows, which takes several seconds.
</p>
<p>
The way we have written this code, the JavaScript interpreter of
Node.js first has to read the complete result set from the
database, and then it can execute the <em>console.log()</em>
function.
</p>
<p>
If this piece of code actually was, say, PHP, it would work the
same way: read all the results at once, then execute the next line
of code. If this code would be part of a web page script, the user
would have to wait several seconds for the page to load.
</p>
<p>
However, in the execution model of PHP, this would not become a
"global" problem: the web server starts its own PHP process for
every HTTP request it receives. If one of these requests results
in the execution of a slow piece of code, it results in a slow
page load for this particular user, but other users requesting
other pages would not be affected.
</p>
<p>
The execution model of Node.js is different - there is only one
single process. If there is a slow database query somewhere in
this process, this affects the whole process - everything comes
to a halt until the slow query has finished.
</p>
<p>
To avoid this, JavaScript, and therefore Node.js, introduces the
concept of event-driven, asynchronous callbacks, by utilizing an
event loop.
</p>
<p>
We can understand this concept by analyzing a rewritten version
of our problematic code:
</p>
<pre class="prettyprint lang-js">database.query("SELECT * FROM hugetable", function(rows) {
var result = rows;
});
console.log("Hello World");</pre>
<p>
Here, instead of expecting <em>database.query()</em> to directly
return a result to us, we pass it a second parameter, an anonymous
function.
</p>
<p>
In its previous form, our code was synchronous: <em>first</em>
do the database query, and only when this is done, <em>then</em>
write to the console.
</p>
<p>
Now, Node.js can handle the database request asynchronously.
Provided that <em>database.query()</em> is part of an asynchronous
library, this is what Node.js does: just as before, it takes the
query and sends it to the database. But instead of waiting for it
to be finished, it makes a mental note that says "When at some
point in the future the database server is done and sends the
result of the query, then I have to execute the anonymous function
that was passed to <em>database.query()</em>."
</p>
<p>
Then, it immediately executes <em>console.log()</em>, and
afterwards, it enters the event loop. Node.js continuously cycles
through this loop again and again whenever there is nothing else
to do, waiting for events. Events like, e.g., a slow database
query finally delivering its results.
</p>
<p>
This also explains why our HTTP server needs a function it can
call upon incoming requests - if Node.js would start the server
and then just pause, waiting for the next request, continuing
only when it arrives, that would be highly inefficent. If a second
user requests the server while it is still serving the first
request, that second request could only be answered after the first
one is done - as soon as you have more than a handful of HTTP
requests per second, this wouldn't work at all.
</p>
<p>
It's important to note that this asynchronous, single-threaded,
event-driven execution model isn't an infinitely scalable
performance unicorn with silver bullets attached. It is just one
of several models, and it has its limitations, one being that as
of now, Node.js is just one single process, and it can run on only
one single CPU core. Personally, I find this model quite
approachable, because it allows to write applications that have to
deal with concurrency in an efficient and relatively
straightforward manner.
</p>
<p>
You might want to take the time to read Felix
Geisendörfer's excellent post
<a href="http://debuggable.com/posts/understanding-node-js:4bd98440-45e4-4a9a-8ef7-0f7ecbdd56cb">Understanding
node.js</a>
for additional background explanation.
</p>
<p>
Let's play around a bit with this new concept. Can we prove
that our code continues after creating the server, even if
no HTTP request happened and the callback function we
passed isn't called? Let's try it:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> http </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br><br></span><span class="kwd">function</span><span
class="pln"> onRequest</span><span class="pun">(</span><span class="pln">request</span><span
class="pun">,</span><span class="pln"> response</span><span class="pun">)</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request received."</span><span
class="pun">);</span><span class="pln"><br>&nbsp; response</span><span class="pun">.</span><span
class="pln">writeHead</span><span class="pun">(</span><span class="lit">200</span><span
class="pun">,</span><span class="pln"> </span><span class="pun">{</span><span
class="str">"Content-Type"</span><span class="pun">:</span><span class="pln"> </span><span class="str">"text/plain"</span><span
class="pun">});</span><span class="pln"><br>&nbsp; response</span><span class="pun">.</span><span
class="pln">write</span><span class="pun">(</span><span class="str">"Hello World"</span><span
class="pun">);</span><span class="pln"><br>&nbsp; response</span><span class="pun">.</span><span
class="pln">end</span><span class="pun">();</span><span class="pln"><br></span><span
class="pun">}</span><span class="pln"><br><br>http</span><span class="pun">.</span><span class="pln">createServer</span><span
class="pun">(</span><span class="pln">onRequest</span><span class="pun">).</span><span class="pln">listen</span><span
class="pun">(</span><span class="lit">8888</span><span class="pun">);</span><span class="pln"><br><br>console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Server has started."</span><span
class="pun">);</span></pre>
<p>
Note that I use <em>console.log</em> to output a text whenever
the <em>onRequest</em> function (our callback) is triggered,
and another text right <em>after</em> starting the HTTP server.
</p>
<p>
When we start this (<em>node server.js</em>, as always), it
will immediately output "Server has started." on the
command line. Whenever we request our server (by opening
<a href="http://localhost:8888/" rel="nofollow">http://localhost:8888/</a>
in our browser), the message "Request received." is printed
on the command line.
</p>
<p>
Event-driven asynchronous server-side JavaScript with
callbacks in action :-)
</p>
<p>
(Note that our server will probably write "Request received."
to STDOUT two times upon opening the page in a browser. That's
because most browsers will try to load the favicon by requesting
http://localhost:8888/favicon.ico whenever you open
http://localhost:8888/).
</p>
<a name="how-our-server-handles-requests"></a>
<h3>How our server handles requests</h3>
<p>
Ok, let's quickly analyze the rest of our server code, that
is, the body of our callback function <em>onRequest()</em>.
</p>
<p>
When the callback fires and our <em>onRequest()</em> function
gets triggered, two parameters are passed into it:
<em>request</em> and <em>response</em>.
</p>
<p>
Those are objects, and you can use their methods to handle
the details of the HTTP request that occured and to respond
to the request (i.e., to actually send something over
the wire back to the browser that requested your server).
</p>
<p>
And our code does just that: Whenever a request is
received, it uses the <em>response.writeHead()</em>
function to send an HTTP status 200 and content-type in the
HTTP response header, and the <em>response.write()</em>
function to send the text "Hello World" in the HTTP
response body.
</p>
<p>
At last, we call <em>response.end()</em> to actually finish
our response.
</p>
<p>
At this point, we don't care for the details of the
request, which is why we don't use the <em>request</em>
object at all.
</p>
<a name="finding-a-place-for-our-server-module"></a>
<h3>Finding a place for our server module</h3>
<p>
Ok, I promised we will get back to how to organize our
application. We have the code for a very basic HTTP server in
the file <em>server.js</em>, and I mentioned that it's common
to have a main file called <em>index.js</em> which is used
to bootstrap and start our application by making use of the
other modules of the application (like the HTTP server module
that lives in <em>server.js</em>).
</p>
<p>
Let's talk about how to make server.js a real Node.js module
that can be used by our yet-to-be-written <em>index.js</em>
main file.
</p>
<p>
As you may have noticed, we already used modules in our code,
like this:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> http </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br><br></span><span class="pun">...</span><span
class="pln"><br><br>http</span><span class="pun">.</span><span class="pln">createServer</span><span
class="pun">(...);</span></pre>
<p>
Somewhere within Node.js lives a module called "http", and we can
make use of it in our own code by requiring it and assigning
the result of the require to a local variable.
</p>
<p>
This makes our local variable an object that carries all the
public methods the <em>http</em> module provides.
</p>
<p>
It's common practice to choose the name of the module for the
name of the local variable, but we are free to choose whatever
we like:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> foo </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br><br></span><span class="pun">...</span><span
class="pln"><br><br>foo</span><span class="pun">.</span><span class="pln">createServer</span><span
class="pun">(...);</span></pre>
<p>
Fine, it's clear how to make use of internal Node.js modules. How
do we create our own modules, and how do we use them?
</p>
<p>
Let's find out by turning our <em>server.js</em> script into a
real module.
</p>
<p>
Turns out, we don't have to change that much. Making some code
a module means we need to <em>export</em> those parts of its
functionality that we want to provide to scripts that require
our module.
</p>
<p>
For now, the functionality our HTTP server needs to export is
simple: scripts requiring our server module simply need to
start the server.
</p>
<p>
To make this possible, we will put our server code into a
function named <em>start</em>, and we will export this
function:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> http </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br><br></span><span class="kwd">function</span><span
class="pln"> start</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span><span
class="pln"><br>&nbsp; </span><span class="kwd">function</span><span class="pln"> onRequest</span><span
class="pun">(</span><span class="pln">request</span><span class="pun">,</span><span class="pln"> response</span><span
class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request received."</span><span
class="pun">);</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">writeHead</span><span class="pun">(</span><span class="lit">200</span><span
class="pun">,</span><span class="pln"> </span><span class="pun">{</span><span
class="str">"Content-Type"</span><span class="pun">:</span><span class="pln"> </span><span class="str">"text/plain"</span><span
class="pun">});</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">write</span><span class="pun">(</span><span class="str">"Hello World"</span><span
class="pun">);</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">end</span><span class="pun">();</span><span class="pln"><br>&nbsp; </span><span class="pun">}</span><span
class="pln"><br><br>&nbsp; http</span><span class="pun">.</span><span
class="pln">createServer</span><span class="pun">(</span><span class="pln">onRequest</span><span
class="pun">).</span><span class="pln">listen</span><span class="pun">(</span><span
class="lit">8888</span><span class="pun">);</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Server has started."</span><span
class="pun">);</span><span class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>exports</span><span
class="pun">.</span><span class="pln">start </span><span class="pun">=</span><span
class="pln"> start</span><span class="pun">;</span></pre>
<p>
This way, we can now create our main file <em>index.js</em>,
and start our HTTP there, although the code for the server is
still in our <em>server.js</em> file.
</p>
<p>
Create a file <em>index.js</em> with the following content:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> server </span><span class="pun">=</span><span
class="pln"> require</span><span class="pun">(</span><span class="str">"./server"</span><span
class="pun">);</span><span class="pln"><br><br>server</span><span class="pun">.</span><span class="pln">start</span><span
class="pun">();</span></pre>
<p>
As you can see, we can use our server module just like any
internal module: by requiring its file and assigning it to
a variable, its exported functions become available to us.
</p>
<p>
That's it. We can now start our app via our main script, and it
still does exactly the same:
</p>
<pre>node index.js</pre>
<p>
Great, we now can put the different parts of our application
into different files and wire them together by making them
modules.
</p>
<p>
We still have only the very first part of our application in
place: we can receive HTTP requests. But we need to do
something with them - depending on which URL the browser
requested from our server, we need to react differently.
</p>
<p>
For a very simple application, you could do this directly
within the callback function <em>onRequest()</em>. But as I said,
let's add a bit more abstraction in order to make our example
application a bit more interesting.
</p>
<p>
Making different HTTP requests point at different parts of our
code is called "routing" - well, then, let's create a module
called <em>router</em>.
</p>
<a name="whats-needed-to-route-requests"></a>
<h3>What's needed to "route" requests?</h3>
<p>
We need to be able to feed the requested URL and possible
additional GET and POST parameters into our router, and based
on these the router then needs to be able to decide which code
to execute (this "code to execute" is the third part of our
application: a collection of request handlers that do the
actual work when a request is received).
</p>
<p>
So, we need to look into the HTTP requests and extract the
requested URL as well as the GET/POST parameters from them.
It could be argued if that should be part of the router or
part of the server (or even a module of its own), but let's
just agree on making it part of our HTTP server for now.
</p>
<p>
All the information we need is available through the
<em>request</em> object which is passed as the first parameter
to our callback function <em>onRequest()</em>. But to interpret
this information, we need some additional Node.js modules, namely
<em>url</em> and <em>querystring</em>.
</p>
<a name="head20"></a>
<p>
The <em>url</em> module provides methods which allow us to
extract the different parts of a URL (like e.g. the requested
path and query string), and <em>querystring</em> can in turn be
used to parse the query string for request parameters:
</p>
<pre> url.parse(string).query
|
url.parse(string).pathname |
| |
| |
------ -------------------
http://localhost:8888/start?foo=bar&amp;hello=world
--- -----
| |
| |
querystring(string)["foo"] |
|
querystring(string)["hello"]
</pre>
<p>
We can, of course, also use <em>querystring</em> to parse the
body of a POST request for parameters, as we will see
later.
</p>
<p>
Let's now add to our <em>onRequest()</em> function the logic
needed to find out which URL path the browser requested:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> http </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br></span><span
class="kwd">var</span><span class="pln"> url </span><span class="pun">=</span><span
class="pln"> require</span><span class="pun">(</span><span class="str">"url"</span><span
class="pun">);</span><span class="pln"><br><br></span><span class="kwd">function</span><span
class="pln"> start</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span><span
class="pln"><br>&nbsp; </span><span class="kwd">function</span><span class="pln"> onRequest</span><span
class="pun">(</span><span class="pln">request</span><span class="pun">,</span><span class="pln"> response</span><span
class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; </span><span
class="kwd">var</span><span class="pln"> pathname </span><span class="pun">=</span><span class="pln"> url</span><span
class="pun">.</span><span class="pln">parse</span><span class="pun">(</span><span
class="pln">request</span><span class="pun">.</span><span class="pln">url</span><span
class="pun">).</span><span class="pln">pathname</span><span class="pun">;</span><span class="pln"><br>&nbsp; &nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request for "</span><span
class="pln"> </span><span class="pun">+</span><span class="pln"> pathname </span><span
class="pun">+</span><span class="pln"> </span><span class="str">" received."</span><span
class="pun">);</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">writeHead</span><span class="pun">(</span><span class="lit">200</span><span
class="pun">,</span><span class="pln"> </span><span class="pun">{</span><span
class="str">"Content-Type"</span><span class="pun">:</span><span class="pln"> </span><span class="str">"text/plain"</span><span
class="pun">});</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">write</span><span class="pun">(</span><span class="str">"Hello World"</span><span
class="pun">);</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">end</span><span class="pun">();</span><span class="pln"><br>&nbsp; </span><span class="pun">}</span><span
class="pln"><br><br>&nbsp; http</span><span class="pun">.</span><span
class="pln">createServer</span><span class="pun">(</span><span class="pln">onRequest</span><span
class="pun">).</span><span class="pln">listen</span><span class="pun">(</span><span
class="lit">8888</span><span class="pun">);</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Server has started."</span><span
class="pun">);</span><span class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>exports</span><span
class="pun">.</span><span class="pln">start </span><span class="pun">=</span><span
class="pln"> start</span><span class="pun">;</span></pre>
<p>
Fine. Our application can now distinguish requests based on the
URL path requested - this allows us to map requests to our
request handlers based on the URL path using our (yet to be
written) router.
</p>
<p>
In the context of our application, it simply means that we will
be able to have requests for the <em>/start</em> and
<em>/upload</em> URLs handled by different parts of our
code. We will see how everything fits together soon.
</p>
<p>
Ok, it's time to actually write our router. Create a new file
called <em>router.js</em>, with the following content:
</p>
<pre class="prettyprint lang-js"><span class="kwd">function</span><span class="pln"> route</span><span
class="pun">(</span><span class="pln">pathname</span><span class="pun">)</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"About to route a request for "</span><span
class="pln"> </span><span class="pun">+</span><span class="pln"> pathname</span><span
class="pun">);</span><span class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>exports</span><span
class="pun">.</span><span class="pln">route </span><span class="pun">=</span><span
class="pln"> route</span><span class="pun">;</span></pre>
<p>
Of course, this code basically does nothing, but that's ok for
now. Let's first see how to wire together this router with our
server before putting more logic into the router.
</p>
<p>
Our HTTP server needs to know about and make use of our router.
We could hard-wire this dependency into the server, but because
we learned the hard way from our experience with other
programming languages, we are going to loosely couple server
and router by injecting this dependency (you may want to read
<a href="http://martinfowler.com/articles/injection.html">Martin Fowlers excellent post on Dependency Injection</a>
for background information).
</p>
<p>
Let's first extend our server's <em>start()</em> function in
order to enable us to pass the route function to be used by
parameter:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> http </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br></span><span
class="kwd">var</span><span class="pln"> url </span><span class="pun">=</span><span
class="pln"> require</span><span class="pun">(</span><span class="str">"url"</span><span
class="pun">);</span><span class="pln"><br><br></span><span class="kwd">function</span><span
class="pln"> start</span><span class="pun">(</span><span class="pln">route</span><span
class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span
class="pln"><br>&nbsp; </span><span class="kwd">function</span><span class="pln"> onRequest</span><span
class="pun">(</span><span class="pln">request</span><span class="pun">,</span><span class="pln"> response</span><span
class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; </span><span
class="kwd">var</span><span class="pln"> pathname </span><span class="pun">=</span><span class="pln"> url</span><span
class="pun">.</span><span class="pln">parse</span><span class="pun">(</span><span
class="pln">request</span><span class="pun">.</span><span class="pln">url</span><span
class="pun">).</span><span class="pln">pathname</span><span class="pun">;</span><span class="pln"><br>&nbsp; &nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request for "</span><span
class="pln"> </span><span class="pun">+</span><span class="pln"> pathname </span><span
class="pun">+</span><span class="pln"> </span><span class="str">" received."</span><span
class="pun">);</span><span class="pln"><br><br>&nbsp; &nbsp; route</span><span class="pun">(</span><span
class="pln">pathname</span><span class="pun">);</span><span
class="pln"><br><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">writeHead</span><span class="pun">(</span><span class="lit">200</span><span
class="pun">,</span><span class="pln"> </span><span class="pun">{</span><span
class="str">"Content-Type"</span><span class="pun">:</span><span class="pln"> </span><span class="str">"text/plain"</span><span
class="pun">});</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">write</span><span class="pun">(</span><span class="str">"Hello World"</span><span
class="pun">);</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">end</span><span class="pun">();</span><span class="pln"><br>&nbsp; </span><span class="pun">}</span><span
class="pln"><br><br>&nbsp; http</span><span class="pun">.</span><span
class="pln">createServer</span><span class="pun">(</span><span class="pln">onRequest</span><span
class="pun">).</span><span class="pln">listen</span><span class="pun">(</span><span
class="lit">8888</span><span class="pun">);</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Server has started."</span><span
class="pun">);</span><span class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>exports</span><span
class="pun">.</span><span class="pln">start </span><span class="pun">=</span><span
class="pln"> start</span><span class="pun">;</span></pre>
<p>
And let's extend our <em>index.js</em> accordingly, that is,
injecting the route function of our router into the server:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> server </span><span class="pun">=</span><span
class="pln"> require</span><span class="pun">(</span><span class="str">"./server"</span><span
class="pun">);</span><span class="pln"><br></span><span class="kwd">var</span><span
class="pln"> router </span><span class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"./router"</span><span class="pun">);</span><span class="pln"><br><br>server</span><span
class="pun">.</span><span class="pln">start</span><span class="pun">(</span><span
class="pln">router</span><span class="pun">.</span><span class="pln">route</span><span
class="pun">);</span><span class="pln"><br></span></pre>
<p>
Again, we are passing a function, which by now isn't any news
for us.
</p>
<p>
If we start our application now (<em>node index.js,
as always</em>), and request an URL, you can now see from the
application's output that our HTTP server makes use of our
router and passes it the requested pathname:
</p>
<pre>bash$ node index.js
Request for /foo received.
About to route a request for /foo</pre>
<p>
(I omitted the rather annoying output for the /favicon.ico
request).
</p>
<a name="execution-in-the-kongdom-of-verbs"></a>
<h3>Execution in the kingdom of verbs</h3>
<p>
May I once again stray away for a while and talk about
functional programming again?
</p>
<p>
Passing functions is not only a technical consideration.
With regard to software design, it's almost philosophical.
Just think about it: in our index file, we could have passed
the <em>router</em> object into the server, and the server
could have called this object's <em>route</em> function.
</p>
<p>
This way, we would have passed a <em>thing</em>, and the server
would have used this thing to <em>do</em> something. Hey,
router thing, could you please route this for me?
</p>
<p>
But the server doesn't need the thing. It only needs to get
something <em>done</em>, and to get something done, you don't
need things at all, you need <em>actions</em>. You don't need
<em>nouns</em>, you need <em>verbs</em>.
</p>
<p>
Understanding the fundamental mind-shift that's at the core of
this idea is what made me really understand functional
programming.
</p>
<p>
And I did understand it when reading Steve Yegge's masterpiece
<a href="http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.html">Execution in the Kingdom of Nouns</a>.
Go read it now, really. It's one of the best writings related
to software I ever had the pleasure to encounter.
</p>
<a name="routing-to-real-request-handlers"></a>
<h3>Routing to real request handlers</h3>
<p>
Back to business. Our HTTP server and our request router are
now best friends and talk to each other as we intended.
</p>
<p>
Of course, that's not enough. "Routing" means, we want to
handle requests to different URLs differently. We would like to
have the "business logic" for requests to <em>/start</em>
handled in another function than requests to <em>/upload</em>.
</p>
<p>
Right now, the routing "ends" in the router, and the router is
not the place to actually "do" something with the requests,
because that wouldn't scale well once our application becomes
more complex.
</p>
<a name="continuereading"></a>
<p>
Let's call these functions, where requests are routed to,
<em>request handlers</em>. And let's tackle those next, because
unless we have these in place there isn't much sense in doing
anything with the router for now.
</p>
</div>
<div id="salespitch">
<div id="bubble">
<img id="authorimage" src="manuelkiessling.jpg" width="160" height="160"/>
<p>
<br/>
Hi there! Sorry to interrupt you.
</p>
<p>
My name is Manuel Kiessling, I'm the author of this book.
</p>
<p>
If you have read that far, I guess I may assume that you like
the book. I'm pretty sure you also like the fact that it's free,
which is totally fine, and you can continue reading it for free,
which also is totally fine.
</p>
<p>
However, I would like you to consider buying the eBook version
of the book. It's a beautifully crafted package including a PDF,
an ePub, and a MOBI file, which means you can read it on all
kinds of eReaders out there like the Amazon Kindle, the Nook, or
the Sony Reader.
</p>
<p>
But the best thing about it is that it comes bundled with another
great Node.js book: <em>"Hands-on Node.js"</em> by Pedro Teixeira. It's a
complete reference that explains all the Node.js modules in great
detail - it's perfect to dig deeper once you finished <em>The Node
Beginner Book</em>.
</p>
<p>
Both books together would cost a total of $21.98, but we are offering
it as a bundle for only <strong>$9.99</strong>.
You can download it immediately, it's
completely DRM-free, and you will receive any future updates for
both books for free.
</p>
<p>
So, here are the two choices you have right now:
</p>
<div class="box">
<a href="buy-bundle/salespitch.html"><img src="the_node_beginner_book_cover_small.png" height="86" width="57" /></a>
<a href="buy-bundle/salespitch.html"><img src="hands-on_node.js_cover.png" height="86" width="57" /></a>
<br/>
<div class="subinfo">
226 pages in total<br/>
DRM-free<br/>
Free updates<br/>
<strong>Only $9.99</strong>
</div>
<a class="buttonlink" href="buy-bundle/salespitch.html">
<div class="button">Buy this<br />bundle now</div>
</a>
</div>
<div class="orbox">
<strong>OR</strong>
</div>
<div class="box">
<script type="text/javascript">
var showHiddenHalf = function() {
document.getElementById('hiddenhalf').style.opacity = '1.0';
document.getElementById('salespitch').style.display = 'none';
return false;
};
</script>
<a href="#continuereading" onclick="showHiddenHalf();">Continue reading<br/>the free version</a>
</div>
</div>
<br clear="all"/>
</div>
<div id="hiddenhalf">
<p>
New application part, new module - no surprise here. Let's
create a module called requestHandlers, add a placeholder
function for every request handler, and export these as
methods of the module:
</p>
<pre class="prettyprint lang-js"><span class="kwd">function</span><span class="pln"> start</span><span
class="pun">()</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request handler 'start' was called."</span><span
class="pun">);</span><span class="pln"><br></span><span class="pun">}</span><span
class="pln"><br><br></span><span class="kwd">function</span><span class="pln"> upload</span><span
class="pun">()</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request handler 'upload' was called."</span><span
class="pun">);</span><span class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>exports</span><span
class="pun">.</span><span class="pln">start </span><span class="pun">=</span><span
class="pln"> start</span><span class="pun">;</span><span class="pln"><br>exports</span><span
class="pun">.</span><span class="pln">upload </span><span class="pun">=</span><span
class="pln"> upload</span><span class="pun">;</span></pre>
<p>
This allows us to wire the request handlers into the router,
giving our router something to route to.
</p>
<p>
At this point we need to make a decision: do we hard-code usage
of the requestHandlers module into the router, or do we want a
bit more dependency injection? Although dependency injection,
like every other pattern, shouldn't be used only for the sake
of using it, in this case it makes sense to loosely couple the
router and its request handlers, and thus making the router
really reusable.
</p>
<p>
This means we need to pass the request handlers from our server
into our router, but this feels even more wrong, which is why
we should go the whole way and pass them to the server from our
main file, and passing it on to the router from there.
</p>
<p>
How are we going to pass them? Right now we have two handlers,
but in a real application, this number is going to increase and
vary, and we sure don't want to fiddle around mapping requests
to handlers in the router anytime a new URL / request handler
is added. And having some
<em>if request == x then call handler y</em> in the router
would be more than ugly.
</p>
<p>
A varying number of items, each mapped to a string (the
requested URL)? Well, sounds like an associative array would be
a perfect fit.
</p>
<p>
Well, this finding is slightly disappointed by the fact that
JavaScript doesn't provide associative array - or does it?
Turns out, it's actually objects that we want to use if we need
an associative array!
</p>
<p>
There's a nice introduction to this at
<a href="http://msdn.microsoft.com/en-us/magazine/cc163419.aspx">http://msdn.microsoft.com/en-us/magazine/cc163419.aspx</a>,
let me quote the relevant part:
</p>
<blockquote>
<p>
In C++ or C#, when we’re talking about objects, we're
referring to instances of classes or structs. Objects have
different properties and methods, depending on which
templates (that is, classes) they are instantiated from.
That's not the case with JavaScript objects. In JavaScript,
objects are just collections of name/value pairs - think of a
JavaScript object as a dictionary with string keys.
</p>
</blockquote>
<p>
If JavaScript objects are just collections of name/value pairs,
how can they have methods? Well, the values can be strings,
numbers etc. - or functions!
</p>
<p>
Ok, now finally back to the code. We decided we want to pass
the list of requestHandlers as an object, and in order to
achieve loose coupling we want to inject this object into the
<em>route()</em>.
</p>
<p>
Let's start with putting the object together in our main file
<em>index.js</em>:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> server </span><span class="pun">=</span><span
class="pln"> require</span><span class="pun">(</span><span class="str">"./server"</span><span
class="pun">);</span><span class="pln"><br></span><span class="kwd">var</span><span
class="pln"> router </span><span class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"./router"</span><span class="pun">);</span><span class="pln"><br></span><span class="kwd">var</span><span
class="pln"> requestHandlers </span><span class="pun">=</span><span class="pln"> require</span><span
class="pun">(</span><span class="str">"./requestHandlers"</span><span class="pun">);</span><span
class="pln"><br><br></span><span class="kwd">var</span><span class="pln"> handle </span><span
class="pun">=</span><span class="pln"> </span><span class="pun">{}</span><span
class="pln"><br>handle</span><span class="pun">[</span><span class="str">"/"</span><span
class="pun">]</span><span class="pln"> </span><span class="pun">=</span><span class="pln"> requestHandlers</span><span
class="pun">.</span><span class="pln">start</span><span class="pun">;</span><span class="pln"><br>handle</span><span
class="pun">[</span><span class="str">"/start"</span><span class="pun">]</span><span
class="pln"> </span><span class="pun">=</span><span class="pln"> requestHandlers</span><span
class="pun">.</span><span class="pln">start</span><span class="pun">;</span><span class="pln"><br>handle</span><span
class="pun">[</span><span class="str">"/upload"</span><span class="pun">]</span><span
class="pln"> </span><span class="pun">=</span><span class="pln"> requestHandlers</span><span
class="pun">.</span><span class="pln">upload</span><span class="pun">;</span><span class="pln"><br><br>server</span><span
class="pun">.</span><span class="pln">start</span><span class="pun">(</span><span
class="pln">router</span><span class="pun">.</span><span class="pln">route</span><span
class="pun">,</span><span class="pln"> handle</span><span class="pun">);</span></pre>
<p>
Although <em>handle</em> is more of a "thing" (a collection of
request handlers), I propose we name it like a verb, because
this will result in a fluent expression in our router, as we
will see soon.
</p>
<p>
As you can see, it's really simple to map different URLs to the
same request handler: by adding a key/value pair of
<em>"/"</em> and <em>requestHandlers.start</em>, we can express
in a nice and clean way that not only requests to
<em>/start</em>, but also requests to <em>/</em> shall be
handled by the <em>start</em> handler.
</p>
<p>
After defining our object, we pass it into the server as an
additional parameter. Let's change our <em>server.js</em> to
make use of it:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> http </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br></span><span
class="kwd">var</span><span class="pln"> url </span><span class="pun">=</span><span
class="pln"> require</span><span class="pun">(</span><span class="str">"url"</span><span
class="pun">);</span><span class="pln"><br><br></span><span class="kwd">function</span><span
class="pln"> start</span><span class="pun">(</span><span class="pln">route</span><span
class="pun">,</span><span class="pln"> handle</span><span class="pun">)</span><span class="pln"> </span><span
class="pun">{</span><span class="pln"><br>&nbsp; </span><span class="kwd">function</span><span
class="pln"> onRequest</span><span class="pun">(</span><span class="pln">request</span><span
class="pun">,</span><span class="pln"> response</span><span class="pun">)</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; </span><span
class="kwd">var</span><span class="pln"> pathname </span><span class="pun">=</span><span class="pln"> url</span><span
class="pun">.</span><span class="pln">parse</span><span class="pun">(</span><span
class="pln">request</span><span class="pun">.</span><span class="pln">url</span><span
class="pun">).</span><span class="pln">pathname</span><span class="pun">;</span><span class="pln"><br>&nbsp; &nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request for "</span><span
class="pln"> </span><span class="pun">+</span><span class="pln"> pathname </span><span
class="pun">+</span><span class="pln"> </span><span class="str">" received."</span><span
class="pun">);</span><span class="pln"><br><br>&nbsp; &nbsp; route</span><span class="pun">(</span><span
class="pln">handle</span><span class="pun">,</span><span class="pln"> pathname</span><span class="pun">);</span><span
class="pln"><br><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">writeHead</span><span class="pun">(</span><span class="lit">200</span><span
class="pun">,</span><span class="pln"> </span><span class="pun">{</span><span
class="str">"Content-Type"</span><span class="pun">:</span><span class="pln"> </span><span class="str">"text/plain"</span><span
class="pun">});</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">write</span><span class="pun">(</span><span class="str">"Hello World"</span><span
class="pun">);</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">end</span><span class="pun">();</span><span class="pln"><br>&nbsp; </span><span class="pun">}</span><span
class="pln"><br><br>&nbsp; http</span><span class="pun">.</span><span
class="pln">createServer</span><span class="pun">(</span><span class="pln">onRequest</span><span
class="pun">).</span><span class="pln">listen</span><span class="pun">(</span><span
class="lit">8888</span><span class="pun">);</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Server has started."</span><span
class="pun">);</span><span class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>exports</span><span
class="pun">.</span><span class="pln">start </span><span class="pun">=</span><span
class="pln"> start</span><span class="pun">;</span></pre>
<p>
We've added the <em>handle</em> parameter to our
<em>start()</em> function, and pass the handle object on to
the <em>route()</em> callback, as its first parameter.
</p>
<p>
Let's change the <em>route()</em> function accordingly, in our
<em>router.js</em> file:
</p>
<pre class="prettyprint lang-js"><span class="kwd">function</span><span class="pln"> route</span><span
class="pun">(</span><span class="pln">handle</span><span class="pun">,</span><span
class="pln"> pathname</span><span class="pun">)</span><span class="pln"> </span><span
class="pun">{</span><span class="pln"><br>&nbsp; console</span><span class="pun">.</span><span
class="pln">log</span><span class="pun">(</span><span class="str">"About to route a request for "</span><span
class="pln"> </span><span class="pun">+</span><span class="pln"> pathname</span><span
class="pun">);</span><span class="pln"><br>&nbsp; </span><span class="kwd">if</span><span
class="pln"> </span><span class="pun">(</span><span class="kwd">typeof</span><span
class="pln"> handle</span><span class="pun">[</span><span class="pln">pathname</span><span
class="pun">]</span><span class="pln"> </span><span class="pun">===</span><span
class="pln"> </span><span class="str">'function'</span><span class="pun">)</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; handle</span><span
class="pun">[</span><span class="pln">pathname</span><span class="pun">]();</span><span class="pln"><br>&nbsp; </span><span
class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"No request handler found for "</span><span
class="pln"> </span><span class="pun">+</span><span class="pln"> pathname</span><span
class="pun">);</span><span class="pln"><br>&nbsp; </span><span class="pun">}</span><span
class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>exports</span><span
class="pun">.</span><span class="pln">route </span><span class="pun">=</span><span
class="pln"> route</span><span class="pun">;</span></pre>
<p>
What we do here is, we check if a request handler for the given
pathname exists, and if it does, we simply call the corresponding
function. Because we can access our request handler functions
from our object just as we would access an element of an
associative array, we have this nice fluent
<em>handle[pathname]();</em> expression I talked about earlier:
"Please, <em>handle</em> this <em>pathname</em>".
</p>
<p>
Ok, that's all we need to wire server, router, and request
handlers together! When starting our application and requesting
<a href="http://localhost:8888/start" rel="nofollow">http://localhost:8888/start</a>
in our browser, we can prove that the correct request handler
was indeed called:
</p>
<pre>Server has started.
Request for /start received.
About to route a request for /start
Request handler 'start' was called.</pre>
<p>
And opening <a href="http://localhost:8888/" rel="nofollow">http://localhost:8888/</a>
in our browser proves that these requests, too, are indeed handled by
the <em>start</em> request handler:
</p>
<pre>Request for / received.
About to route a request for /
Request handler 'start' was called.</pre>
<a name="making-the-request-handlers-respond"></a>
<h3>Making the request handlers respond</h3>
<p>
Beautiful. Now if only the request handlers could actually send
something back to the browser, that would be even better,
right?
</p>
<p>
Remember, the "Hello World" your browser displays upon
requesting a page still comes from the <em>onRequest</em>
function in our <em>server.js</em> file.
</p>
<p>
"Handling request" means "answering requests" after all, thus
we need to enable our request handlers to speak with the
browser just like our <em>onRequest</em> function does.
</p>
<a name="how-to-not-do-it"></a>
<h4>How to not do it</h4>
<p>
The straight-forward approach we - as developers with a
background in PHP or Ruby - might want to follow is actually
very deceitful: it works like a charm, seems to make a lot of
sense, and then suddenly screws things up when we don't expect
it.
</p>
<p>
What I mean by "straight-forward approach" is this: make the
request handlers <em>return()</em> the content they want to
display to the user, and send this response data in the
<em>onRequest</em> function back to the user.
</p>
<p>
Let's just do this, and then see why it's not such an overly
good idea.
</p>
<p>
We start with the request handlers and make them return what we
would like to display in the browser. We need to change
<em>requestHandlers.js</em> to this:
</p>
<pre class="prettyprint lang-js"><span class="kwd">function</span><span class="pln"> start</span><span
class="pun">()</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request handler 'start' was called."</span><span
class="pun">);</span><span class="pln"><br>&nbsp; </span><span class="kwd">return</span><span
class="pln"> </span><span class="str">"Hello Start"</span><span class="pun">;</span><span
class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br></span><span class="kwd">function</span><span
class="pln"> upload</span><span class="pun">()</span><span class="pln"> </span><span
class="pun">{</span><span class="pln"><br>&nbsp; console</span><span class="pun">.</span><span
class="pln">log</span><span class="pun">(</span><span
class="str">"Request handler 'upload' was called."</span><span class="pun">);</span><span
class="pln"><br>&nbsp; </span><span class="kwd">return</span><span class="pln"> </span><span
class="str">"Hello Upload"</span><span class="pun">;</span><span class="pln"><br></span><span
class="pun">}</span><span class="pln"><br><br>exports</span><span class="pun">.</span><span class="pln">start </span><span
class="pun">=</span><span class="pln"> start</span><span class="pun">;</span><span class="pln"><br>exports</span><span
class="pun">.</span><span class="pln">upload </span><span class="pun">=</span><span
class="pln"> upload</span><span class="pun">;</span></pre>
<p>
Good. Likewise, the router needs to return to the server what
the request handlers return to him. We therefore need to edit
<em>router.js</em> like this:
</p>
<pre class="prettyprint lang-js"><span class="kwd">function</span><span class="pln"> route</span><span
class="pun">(</span><span class="pln">handle</span><span class="pun">,</span><span
class="pln"> pathname</span><span class="pun">)</span><span class="pln"> </span><span
class="pun">{</span><span class="pln"><br>&nbsp; console</span><span class="pun">.</span><span
class="pln">log</span><span class="pun">(</span><span class="str">"About to route a request for "</span><span
class="pln"> </span><span class="pun">+</span><span class="pln"> pathname</span><span
class="pun">);</span><span class="pln"><br>&nbsp; </span><span class="kwd">if</span><span
class="pln"> </span><span class="pun">(</span><span class="kwd">typeof</span><span
class="pln"> handle</span><span class="pun">[</span><span class="pln">pathname</span><span
class="pun">]</span><span class="pln"> </span><span class="pun">===</span><span
class="pln"> </span><span class="str">'function'</span><span class="pun">)</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; </span><span
class="kwd">return</span><span class="pln"> handle</span><span class="pun">[</span><span class="pln">pathname</span><span
class="pun">]();</span><span class="pln"><br>&nbsp; </span><span class="pun">}</span><span
class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span
class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; console</span><span class="pun">.</span><span
class="pln">log</span><span class="pun">(</span><span class="str">"No request handler found for "</span><span
class="pln"> </span><span class="pun">+</span><span class="pln"> pathname</span><span
class="pun">);</span><span class="pln"><br>&nbsp; &nbsp; </span><span class="kwd">return</span><span
class="pln"> </span><span class="str">"404 Not found"</span><span class="pun">;</span><span class="pln"><br>&nbsp; </span><span
class="pun">}</span><span class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>exports</span><span
class="pun">.</span><span class="pln">route </span><span class="pun">=</span><span
class="pln"> route</span><span class="pun">;</span></pre>
<p>
As you can see, we also return some text if the request could
not be routed.
</p>
<p>
And last but not least, we need to refactor our server to make
it respond to the browser with the content the request handlers
returned via the router, transforming <em>server.js</em> into:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> http </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br></span><span
class="kwd">var</span><span class="pln"> url </span><span class="pun">=</span><span
class="pln"> require</span><span class="pun">(</span><span class="str">"url"</span><span
class="pun">);</span><span class="pln"><br><br></span><span class="kwd">function</span><span
class="pln"> start</span><span class="pun">(</span><span class="pln">route</span><span
class="pun">,</span><span class="pln"> handle</span><span class="pun">)</span><span class="pln"> </span><span
class="pun">{</span><span class="pln"><br>&nbsp; </span><span class="kwd">function</span><span
class="pln"> onRequest</span><span class="pun">(</span><span class="pln">request</span><span
class="pun">,</span><span class="pln"> response</span><span class="pun">)</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; </span><span
class="kwd">var</span><span class="pln"> pathname </span><span class="pun">=</span><span class="pln"> url</span><span
class="pun">.</span><span class="pln">parse</span><span class="pun">(</span><span
class="pln">request</span><span class="pun">.</span><span class="pln">url</span><span
class="pun">).</span><span class="pln">pathname</span><span class="pun">;</span><span class="pln"><br>&nbsp; &nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request for "</span><span
class="pln"> </span><span class="pun">+</span><span class="pln"> pathname </span><span
class="pun">+</span><span class="pln"> </span><span class="str">" received."</span><span
class="pun">);</span><span class="pln"><br><br>&nbsp; &nbsp; response</span><span
class="pun">.</span><span class="pln">writeHead</span><span class="pun">(</span><span
class="lit">200</span><span class="pun">,</span><span class="pln"> </span><span
class="pun">{</span><span class="str">"Content-Type"</span><span class="pun">:</span><span
class="pln"> </span><span class="str">"text/plain"</span><span class="pun">});</span><span
class="pln"><br>&nbsp; &nbsp; </span><span class="kwd">var</span><span class="pln"> content </span><span
class="pun">=</span><span class="pln"> route</span><span class="pun">(</span><span
class="pln">handle</span><span class="pun">,</span><span class="pln"> pathname</span><span
class="pun">)</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">write</span><span class="pun">(</span><span class="pln">content</span><span
class="pun">);</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">end</span><span class="pun">();</span><span class="pln"><br>&nbsp; </span><span class="pun">}</span><span
class="pln"><br><br>&nbsp; http</span><span class="pun">.</span><span
class="pln">createServer</span><span class="pun">(</span><span class="pln">onRequest</span><span
class="pun">).</span><span class="pln">listen</span><span class="pun">(</span><span
class="lit">8888</span><span class="pun">);</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Server has started."</span><span
class="pun">);</span><span class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>exports</span><span
class="pun">.</span><span class="pln">start </span><span class="pun">=</span><span
class="pln"> start</span><span class="pun">;</span></pre>
<p>
If we start our rewritten application, everything works like
a charm: requesting <a href="http://localhost:8888/start" rel="nofollow">http://localhost:8888/start</a>
results in "Hello Start" being displayed in the browser,
requesting <a href="http://localhost:8888/upload" rel="nofollow">http://localhost:8888/upload</a>
gives us "Hello Upload", and <a href="http://localhost:8888/foo" rel="nofollow">http://localhost:8888/foo</a>
produces "404 Not found".
</p>
<p>
Ok, then why is that a problem? The short answer: because we
will run into problems if one of the request handlers wants to make
use of a non-blocking operation in the future.
</p>
<p>
Let's take a bit more time for the long answer.
</p>
<a name="blocking-and-non-blocking"></a>
<h4>Blocking and non-blocking</h4>
<p>
As said, the problems will arise when we include non-blocking
operations in the request handlers. But let's talk about
blocking operations first, then about non-blocking operations.
</p>
<p>
And instead of trying to explain what "blocking" and
"non-blocking" means, let's demonstrate ourselves what happens
if we add a blocking operation to our request handlers.
</p>
<p>
To do this, we will modify our <em>start</em> request handler
to make it wait 10 seconds before returning its "Hello Start"
string. Because there is no such thing as <em>sleep()</em> in
JavaScript, we will use a clever hack for that.
</p>
<p>
Please modify <em>requestHandlers.js</em> as follows:
</p>
<pre class="prettyprint lang-js"><span class="kwd">function</span><span class="pln"> start</span><span
class="pun">()</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request handler 'start' was called."</span><span
class="pun">);</span><span class="pln"><br><br>&nbsp; </span><span class="kwd">function</span><span
class="pln"> sleep</span><span class="pun">(</span><span class="pln">milliSeconds</span><span
class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; </span><span
class="kwd">var</span><span class="pln"> startTime </span><span class="pun">=</span><span
class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span
class="typ">Date</span><span class="pun">().</span><span class="pln">getTime</span><span
class="pun">();</span><span class="pln"><br>&nbsp; &nbsp; </span><span class="kwd">while</span><span
class="pln"> </span><span class="pun">(</span><span class="kwd">new</span><span
class="pln"> </span><span class="typ">Date</span><span class="pun">().</span><span
class="pln">getTime</span><span class="pun">()</span><span class="pln"> </span><span
class="pun">&lt;</span><span class="pln"> startTime </span><span class="pun">+</span><span class="pln"> milliSeconds</span><span
class="pun">);</span><span class="pln"><br>&nbsp; </span><span class="pun">}</span><span
class="pln"><br><br>&nbsp; sleep</span><span class="pun">(</span><span class="lit">10000</span><span
class="pun">);</span><span class="pln"><br>&nbsp; </span><span class="kwd">return</span><span
class="pln"> </span><span class="str">"Hello Start"</span><span class="pun">;</span><span
class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br></span><span class="kwd">function</span><span
class="pln"> upload</span><span class="pun">()</span><span class="pln"> </span><span
class="pun">{</span><span class="pln"><br>&nbsp; console</span><span class="pun">.</span><span
class="pln">log</span><span class="pun">(</span><span
class="str">"Request handler 'upload' was called."</span><span class="pun">);</span><span
class="pln"><br>&nbsp; </span><span class="kwd">return</span><span class="pln"> </span><span
class="str">"Hello Upload"</span><span class="pun">;</span><span class="pln"><br></span><span
class="pun">}</span><span class="pln"><br><br>exports</span><span class="pun">.</span><span class="pln">start </span><span
class="pun">=</span><span class="pln"> start</span><span class="pun">;</span><span class="pln"><br>exports</span><span
class="pun">.</span><span class="pln">upload </span><span class="pun">=</span><span
class="pln"> upload</span><span class="pun">;</span></pre>
<p>
Just to make clear what that does: when the function
<em>start()</em> is called, Node.js waits 10 seconds and only then
returns "Hello Start". When calling <em>upload()</em>, it
returns immediately, just like before.
</p>
<p>
(Of course, you should imagine that instead of sleeping for
10 seconds, there would be a real life blocking operation in
<em>start()</em>, like some sort of long-running computation.)
</p>
<p>
Let's see what this change does.
</p>
<p>
As always, we need to restart our server. This time, I ask you
to follow a slightly complex "protocol" in order to see what
happens: First, open two browser windows or tabs. In the first
browser window, please enter <a href="http://localhost:8888/start" rel="nofollow">http://localhost:8888/start</a>
into the address bar, but do not yet open this url!
</p>
<p>
In the second browser window's address bar, enter <a href="http://localhost:8888/upload" rel="nofollow">http://localhost:8888/upload</a>,
and again, please do not yet hit enter.
</p>
<p>
Now, do as follows: hit enter on the first window ("/start"),
then quickly change to the second window ("/upload") and hit
enter, too.
</p>
<p>
What you will notice is this: The /start URL takes 10 seconds
to load, as we would expect. But the /upload URL <em>also</em>
takes 10 seconds to load, although there is no <em>sleep()</em>
in the corrsponding request handler.
</p>
<p>
Why? Because <em>start()</em> contains a blocking operation.
We already talked about Node's execution model - expensive
operations are ok, but we must take care to not block the Node.js
process with them. Instead, whenever expensive operations must be
executed, these must be put in the background, and their events
must be handled by the event loop.
</p>
<p>
And we will now see why the way we constructed the "request
handler response handling" in our application doesn't allow us
to make proper use of non-blocking operations.
</p>
<p>
Once again, let's try to experience the problem first-hand by
modifying our application.
</p>
<p>
We are going to use our <em>start</em> request handler for this
again. Please modify it to reflect the following (file
<em>requestHandlers.js</em>):
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> exec </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span class="str">"child_process"</span><span
class="pun">).</span><span class="pln">exec</span><span class="pun">;</span><span
class="pln"><br><br></span><span class="kwd">function</span><span class="pln"> start</span><span
class="pun">()</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request handler 'start' was called."</span><span
class="pun">);</span><span class="pln"><br>&nbsp; </span><span class="kwd">var</span><span class="pln"> content </span><span
class="pun">=</span><span class="pln"> </span><span class="str">"empty"</span><span class="pun">;</span><span
class="pln"><br><br>&nbsp; exec</span><span class="pun">(</span><span class="str">"ls -lah"</span><span
class="pun">,</span><span class="pln"> </span><span class="kwd">function</span><span
class="pln"> </span><span class="pun">(</span><span class="pln">error</span><span
class="pun">,</span><span class="pln"> stdout</span><span class="pun">,</span><span
class="pln"> stderr</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span
class="pln"><br>&nbsp; &nbsp; content </span><span class="pun">=</span><span
class="pln"> stdout</span><span class="pun">;</span><span class="pln"><br>&nbsp; </span><span
class="pun">});</span><span class="pln"><br><br>&nbsp; </span><span class="kwd">return</span><span
class="pln"> content</span><span class="pun">;</span><span class="pln"><br></span><span
class="pun">}</span><span class="pln"><br><br></span><span class="kwd">function</span><span class="pln"> upload</span><span
class="pun">()</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request handler 'upload' was called."</span><span
class="pun">);</span><span class="pln"><br>&nbsp; </span><span class="kwd">return</span><span
class="pln"> </span><span class="str">"Hello Upload"</span><span class="pun">;</span><span
class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>exports</span><span
class="pun">.</span><span class="pln">start </span><span class="pun">=</span><span
class="pln"> start</span><span class="pun">;</span><span class="pln"><br>exports</span><span
class="pun">.</span><span class="pln">upload </span><span class="pun">=</span><span
class="pln"> upload</span><span class="pun">;</span></pre>
<p>
As you can see, we just introduced a new Node.js module,
<em>child_process</em>. We did so because it allows us to make
use of a very simple yet useful non-blocking operation:
<em>exec()</em>.
</p>
<p>
What <em>exec()</em> does is, it executes a shell command from
within Node.js. In this example, we are going to use it to get
a list of all files in the current directory ("ls -lah"),
allowing us to display this list in the browser of a user
requesting the <em>/start</em> URL.
</p>
<p>
What the code does is straightforward: create a new variable
<em>content</em> (with an initial value of "empty"), execute
"ls -lah", fill the variable with the result, and return it.
</p>
<p>
As always, we will start our application, and visit
<a href="http://localhost:8888/start" rel="nofollow">http://localhost:8888/start</a>.
</p>
<p>
Which loads a beautiful web page that displays the string
"empty". What's going wrong here?
</p>
<p>
Well, as you may have already guessed, <em>exec()</em> does its
magic in a non-blocking fashion. That's a good thing, because
this way we can execute very expensive shell operations (like,
e.g., copying huge files around or similar stuff) without
forcing our application into a full stop as the blocking
<em>sleep</em> operation did.
</p>
<p>
(If you would like to prove this, replace "ls -lah" with a
more expensive operation like "find /").
</p>
<p>
But we aren't exactly happy with our elegant non-blocking
operation, when our browser doesn't display its result, right?
</p>
<p>
Well, then, let's fix it. And while we are at it, let's try to
understand why the current architecture doesn't work.
</p>
<p>
The problem is that <em>exec()</em>, in order to work
non-blocking, makes use of a callback function.
</p>
<p>
In our example, it's an anonymous function which is passed as
the second parameter to the <em>exec()</em> function call:
</p>
<pre class="prettyprint lang-js"><span class="kwd">function</span><span class="pln"> </span><span
class="pun">(</span><span class="pln">error</span><span class="pun">,</span><span
class="pln"> stdout</span><span class="pun">,</span><span class="pln"> stderr</span><span
class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; content </span><span
class="pun">=</span><span class="pln"> stdout</span><span class="pun">;</span><span
class="pln"><br></span><span class="pun">}</span></pre>
<p>
And herein lies the root of our problem: our own code is
executed synchronous, which means that immediately after
calling <em>exec()</em>, Node.js continues to execute
<em>return content;</em>. At this point, <em>content</em> is
still "empty", due to the fact that the callback function
passed to <em>exec()</em> has not yet been called - because
<em>exec()</em> operates asynchronous.
</p>
<p>
Now, "ls -lah" is a very inexpensive and fast operation (unless
there are millions of files in the directory). Which is why the
callback is called relatively expeditious - but it nevertheless
happens asynchronously.
</p>
<p>
Thinking about a more expensive command makes this more
obvious: "find /" takes about 1 minute on my
machine, but if I replace "ls -lah" with "find /" in the
request handler, I still immediately receive an HTTP response
when opening the /start URL - it's clear that <em>exec()</em>
does something in the background, while Node.js itself
continues with the application, and we may assume that the
callback function we passed into <em>exec()</em> will be called
only when the "find /" command has finished running.
</p>
<p>
But how can we achieve our goal, i.e. showing the user a list
of files in the current directory?
</p>
<p>
Well, after learning how to <em>not</em> do it, let's discuss
how to make our request handlers respond to browser requests
the right way.
</p>
<a name="responding-request-handlers-with-non-blocking-operations"></a>
<h4>Responding request handlers with non-blocking operations</h4>
<p>
I've just used the phrase "the right way". Dangerous stuff.
Quite often, there is no single "right way".
</p>
<p>
But one possible solution for this is, as often with Node.js,
to pass functions around. Let's examine this.
</p>
<p>
Right now, our application is able to transport the content
(which the request handlers would like to display to the user)
from the request handlers to the HTTP server by returning it
up through the layers of the application (request handler -&gt;
router -&gt; server).
</p>
<p>
Our new approach is as follows: instead of bringing the content
to the server, we will bring the server to the content. To be
more precise, we will inject the <em>response</em> object (from
our server's callback function <em>onRequest()</em>) through
the router into the request handlers. The handlers will then be
able to use this object's functions to respond to requests
themselves.
</p>
<p>
Enough explanation, here is the step by step recipe on how to
change our application.
</p>
<p>
Let's start with our <em>server.js</em>:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> http </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span
class="str">"http"</span><span class="pun">);</span><span class="pln"><br></span><span
class="kwd">var</span><span class="pln"> url </span><span class="pun">=</span><span
class="pln"> require</span><span class="pun">(</span><span class="str">"url"</span><span
class="pun">);</span><span class="pln"><br><br></span><span class="kwd">function</span><span
class="pln"> start</span><span class="pun">(</span><span class="pln">route</span><span
class="pun">,</span><span class="pln"> handle</span><span class="pun">)</span><span class="pln"> </span><span
class="pun">{</span><span class="pln"><br>&nbsp; </span><span class="kwd">function</span><span
class="pln"> onRequest</span><span class="pun">(</span><span class="pln">request</span><span
class="pun">,</span><span class="pln"> response</span><span class="pun">)</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; </span><span
class="kwd">var</span><span class="pln"> pathname </span><span class="pun">=</span><span class="pln"> url</span><span
class="pun">.</span><span class="pln">parse</span><span class="pun">(</span><span
class="pln">request</span><span class="pun">.</span><span class="pln">url</span><span
class="pun">).</span><span class="pln">pathname</span><span class="pun">;</span><span class="pln"><br>&nbsp; &nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request for "</span><span
class="pln"> </span><span class="pun">+</span><span class="pln"> pathname </span><span
class="pun">+</span><span class="pln"> </span><span class="str">" received."</span><span
class="pun">);</span><span class="pln"><br><br>&nbsp; &nbsp; route</span><span class="pun">(</span><span
class="pln">handle</span><span class="pun">,</span><span class="pln"> pathname</span><span
class="pun">,</span><span class="pln"> response</span><span class="pun">);</span><span class="pln"><br>&nbsp; </span><span
class="pun">}</span><span class="pln"><br><br>&nbsp; http</span><span class="pun">.</span><span
class="pln">createServer</span><span class="pun">(</span><span class="pln">onRequest</span><span
class="pun">).</span><span class="pln">listen</span><span class="pun">(</span><span
class="lit">8888</span><span class="pun">);</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Server has started."</span><span
class="pun">);</span><span class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>exports</span><span
class="pun">.</span><span class="pln">start </span><span class="pun">=</span><span
class="pln"> start</span><span class="pun">;</span></pre>
<p>
Instead of expecting a return value from the <em>route()</em>
function, we pass it a third parameter, our <em>response</em>
object. Furthermore, we removed any <em>response</em> method
calls from the <em>onRequest()</em> handler, because we now
expect <em>route</em> to take care of that.
</p>
<p>
Next comes <em>router.js</em>:
</p>
<pre class="prettyprint lang-js"><span class="kwd">function</span><span class="pln"> route</span><span
class="pun">(</span><span class="pln">handle</span><span class="pun">,</span><span
class="pln"> pathname</span><span class="pun">,</span><span class="pln"> response</span><span
class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"About to route a request for "</span><span
class="pln"> </span><span class="pun">+</span><span class="pln"> pathname</span><span
class="pun">);</span><span class="pln"><br>&nbsp; </span><span class="kwd">if</span><span
class="pln"> </span><span class="pun">(</span><span class="kwd">typeof</span><span
class="pln"> handle</span><span class="pun">[</span><span class="pln">pathname</span><span
class="pun">]</span><span class="pln"> </span><span class="pun">===</span><span
class="pln"> </span><span class="str">'function'</span><span class="pun">)</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; handle</span><span
class="pun">[</span><span class="pln">pathname</span><span class="pun">](</span><span class="pln">response</span><span
class="pun">);</span><span class="pln"><br>&nbsp; </span><span class="pun">}</span><span
class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span
class="pun">{</span><span class="pln"><br>&nbsp; &nbsp; console</span><span class="pun">.</span><span
class="pln">log</span><span class="pun">(</span><span class="str">"No request handler found for "</span><span
class="pln"> </span><span class="pun">+</span><span class="pln"> pathname</span><span
class="pun">);</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">writeHead</span><span class="pun">(</span><span class="lit">404</span><span
class="pun">,</span><span class="pln"> </span><span class="pun">{</span><span
class="str">"Content-Type"</span><span class="pun">:</span><span class="pln"> </span><span class="str">"text/plain"</span><span
class="pun">});</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">write</span><span class="pun">(</span><span class="str">"404 Not found"</span><span
class="pun">);</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">end</span><span class="pun">();</span><span class="pln"><br>&nbsp; </span><span class="pun">}</span><span
class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br>exports</span><span
class="pun">.</span><span class="pln">route </span><span class="pun">=</span><span
class="pln"> route</span><span class="pun">;</span></pre>
<p>
Same pattern: instead of expecting a return value from our
request handlers, we pass the <em>response</em> object on.
</p>
<p>
If no request handler can be used, we now take care of
responding with a proper "404" header and body ourselves.
</p>
<p>
And last but not least, we modify <em>requestHandlers.js</em>:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> exec </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span class="str">"child_process"</span><span
class="pun">).</span><span class="pln">exec</span><span class="pun">;</span><span
class="pln"><br><br></span><span class="kwd">function</span><span class="pln"> start</span><span
class="pun">(</span><span class="pln">response</span><span class="pun">)</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request handler 'start' was called."</span><span
class="pun">);</span><span class="pln"><br><br>&nbsp; exec</span><span class="pun">(</span><span
class="str">"ls -lah"</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">function</span><span
class="pln"> </span><span class="pun">(</span><span class="pln">error</span><span
class="pun">,</span><span class="pln"> stdout</span><span class="pun">,</span><span
class="pln"> stderr</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span
class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">writeHead</span><span class="pun">(</span><span class="lit">200</span><span
class="pun">,</span><span class="pln"> </span><span class="pun">{</span><span
class="str">"Content-Type"</span><span class="pun">:</span><span class="pln"> </span><span class="str">"text/plain"</span><span
class="pun">});</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">write</span><span class="pun">(</span><span class="pln">stdout</span><span
class="pun">);</span><span class="pln"><br>&nbsp; &nbsp; response</span><span class="pun">.</span><span
class="pln">end</span><span class="pun">();</span><span class="pln"><br>&nbsp; </span><span class="pun">});</span><span
class="pln"><br></span><span class="pun">}</span><span class="pln"><br><br></span><span class="kwd">function</span><span
class="pln"> upload</span><span class="pun">(</span><span class="pln">response</span><span
class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request handler 'upload' was called."</span><span
class="pun">);</span><span class="pln"><br>&nbsp; response</span><span class="pun">.</span><span
class="pln">writeHead</span><span class="pun">(</span><span class="lit">200</span><span
class="pun">,</span><span class="pln"> </span><span class="pun">{</span><span
class="str">"Content-Type"</span><span class="pun">:</span><span class="pln"> </span><span class="str">"text/plain"</span><span
class="pun">});</span><span class="pln"><br>&nbsp; response</span><span class="pun">.</span><span
class="pln">write</span><span class="pun">(</span><span class="str">"Hello Upload"</span><span
class="pun">);</span><span class="pln"><br>&nbsp; response</span><span class="pun">.</span><span
class="pln">end</span><span class="pun">();</span><span class="pln"><br></span><span
class="pun">}</span><span class="pln"><br><br>exports</span><span class="pun">.</span><span class="pln">start </span><span
class="pun">=</span><span class="pln"> start</span><span class="pun">;</span><span class="pln"><br>exports</span><span
class="pun">.</span><span class="pln">upload </span><span class="pun">=</span><span
class="pln"> upload</span><span class="pun">;</span></pre>
<p>
Our handler functions need to accept the response parameter,
and have to make use of them in order to respond to the
request directly.
</p>
<p>
The <em>start</em> handler will respond from within the
anonymous <em>exec()</em> callback, and the <em>upload</em>
handler still simply replies with "Hello Upload", but now
by making use of the <em>response</em> object.
</p>
<p>
If we start our application again (<em>node index.js</em>),
this should work as expected.
</p>
<p>
If you would like to prove that an expensive operation behind
<em>/start</em> will no longer block requests for
<em>/upload</em> from answering immediately, then modify your
<em>requestHandlers.js</em> as follows:
</p>
<pre class="prettyprint lang-js"><span class="kwd">var</span><span class="pln"> exec </span><span
class="pun">=</span><span class="pln"> require</span><span class="pun">(</span><span class="str">"child_process"</span><span
class="pun">).</span><span class="pln">exec</span><span class="pun">;</span><span
class="pln"><br><br></span><span class="kwd">function</span><span class="pln"> start</span><span
class="pun">(</span><span class="pln">response</span><span class="pun">)</span><span
class="pln"> </span><span class="pun">{</span><span class="pln"><br>&nbsp; console</span><span
class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"Request handler 'start' was called."</span><span
class="pun">);</span><span class="pln"><br><br>&nbsp; exec</span><span class="pun">(</span><span
class="str">"find /"</span><span class="pun">,</span><span class="pln"><br>&nbsp; &nbsp; </span><span
class="pun">{</span><span class="pln"> timeout</span><span class="pun">:</span><span
class="pln"> </span><span class="lit">10000</span><span class="pun">,</span><span
class="pln"> maxBuffer</span><span class="pun">:</span><span class="pln"> </span><span
class="lit">20000</span><span