Because the event model is tied to the DOM in browsers, Node created the EventEmitter class in order to provide some basic event functionality. All event functionality in Node revolves around EventEmitter, because it is also designed to be an interface class for other classes to extend. It would be unusual to call an EventEmiter instance directly.

EventEmitter has a handful of methods, the main two being on and emit. The class provides these methods to other classes to use. The on method creates an event listener for an event:

server.on('event', function(a, b, c) {
  //do things
});

        

The on method takes two parameters: the name of the event to listen for and the function to call when that event is emitted. Since EventEmitter is an interface pseudo-class the class that inherits from EventEmitter is expected to be invoked with the new keyword. Let's look at how we create a new class as a listener.

var utils = require('utils'),
    EventEmitter = require('events').EventEmitter;

var Server = function() {
  console.log('init');
};

utils.inherits(Server, EventEmitter);

var s = new Server();

s.on('abc', function() {
  console.log('abc');
});

        

This example begins by including the utils module so we can use the inherits method. We are going to look at utils in detail later in the chapter, so don't worry too much about how inherits works right now.

We then include the events module. However, we want to access just the specific EventEmitter class inside that module. Note how EventEmitter is capitalized to show it is a class. We didn't use a createEventEmitter method because we aren't planning to use an EventEmitter directly. We simply want to attach its methods to the server class we are going to make.

Once we have included the modules we need, the next step is to create our basic Server class. This offers just one simple function, which logs a message when it is initialized. In a real implementation, we would decorate the Server class prototype with the functions that the class would use. For the sake of simplicity, we've skipped that. The important step is to use sys.inherits to add EventEmitter as a superclass of our Server class.

When we want to use the Server class, we instantiate it with new Server(). This instance of Server will have access to the methods in the superclass (EventEmitter). That means we can add a listener to our instance using the on method.

Right now, however, the event listener we added will never be called, because the abc event isn't fired. We can fix this by adding some code to emit the event.

s.emit('abc');

        

Firing the event listener is as simple as calling the emit method that the Server instance inherited from EventEmitter. It's important to note that these events are instance based. There are no global events. When you call the on method, you attach to a specific EventEmitter-based object. Even the various instances of the Server class don't share events. s from the code sample will not share the same events as another Server instance, such as created by var z = new Server();.

An important part of using events is dealing with callbacks. Chapter 3 looks at best practices in much more depth, but we'll look here at the mechanics of callbacks in Node. They use a few standard patterns, but first let's discuss what is possible.

s.emit('abc', a, b, c);

        

When calling emit, in addition to the event name, you can also pass an arbitrary list of parameters. The previous example included three such parameters. These will be passed to the function listening to the event. When you receive a request event from the http Server, for example, you receive two parameters: req and res. When the request event was emitted, those parameters were passed as the second and third arguments to the emit.

It is important to understand how Node calls the event listeners, because it will affect your programming style. When emit() is called with arguments, the following code is used to call each event listener.

if (arguments.length <= 3) {
  // fast case
  handler.call(this, arguments[1], arguments[2]);
} else {
  // slower
  var args = Array.prototype.slice.call(arguments, 1);
  handler.apply(this, args);
}

        

This code uses both of the JavaScript methods for calling a function from code. If emit() was passed with three or fewer arguments, the method takes a shortcut and uses call. Otherwise it use the slower apply to pass all the arguments as an array. The important thing to recognize here, though, is that Node makes both of these calls using the this argument directly. This means that the context in which the event listeners being called is the context of EventEmitter耒not their original context. Using Node REPL, you can see what is happening when things get called EventEmitter.

> var EventEmitter = require('events').EventEmitter,
...     util = require('util');
> 
> var Server = function() {};
> util.inherits(Server, EventEmitter);
> Server.prototype.outputThis= function(output) {
...   console.log(this);
...   console.log(output); 
... };
[Function]
> 
> Server.prototype.emitOutput = function(input) { 
...   this.emit('output', input);
... };
[Function]
> 
> Server.prototype.callEmitOutput = function() {
...   this.emitOutput('innerEmitOutput');
... };
[Function]
> 
> var s = new Server();
> s.on('output', s.outputThis);
{ _events: { output: [Function] } }
> s.emitOutput('outerEmitOutput');
{ _events: { output: [Function] } }
outerEmitOutput
> s.callEmitOutput();
{ _events: { output: [Function] } }
innerEmitOutput
> s.emit('output', 'Direct');
{ _events: { output: [Function] } }
Direct
true
> 

        

The sample output first sets up a Server class. It includes functions to emit the output event. The outputThis method is attached to output event as an event listener. When we emit the output event from various contexts, we stay within the scope of the EventEmitter object, so the value of this that s.outputThis has access to is the one belonging to the EventEmitter. This means the this variable must be passed in as a parameter and assigned to, if we wish to create event listeners that make use of it.

Acting as an HTTP server is probably the commonest current use case for Node. In the previous chapter, we set up an HTTP server and used it to serve a very simple request. However, HTTP is a lot more multifaceted than that. The server component of the HTTP module provides the raw tools to build complex and comprehensive Web servers. In this chapter, we are going to explore the mechanics of dealing with requests and issuing responses. Even if you end up using a higher level server such as Express, many of the concepts it uses are extensions of those defined here.

As we've already, seen the first step in using HTTP servers is to create a new server using the http.createServer() method. This returns a new instance of a the Server class. This Class has only a few methods, because most of the functionality is going to be provided using events. The http server Class has six events and three methods. The other thing to notice is how most of the methods are used to initialize the server, whereas events are used during its operation.

Let's start by creating the smallest basic HTTP server code we can.

require('http').createServer(function(req,res){res.writeHead(200, {}); res.end('hello world');}).listen(8125);

        

This example is not good code. However, it illustrates some important points. We'll fix the style shortly. The first thing we do is require the http module. Notice how I can chain methods in order to access the module without first assigning it to a variable. Many things in Node return a function,^[8] which allows us to invoke those functions immediately. From the included http module we call createServer. This doesn't have to take any arguments, but we pass it a function to attach to the request event. Finally, we tell the server created with createServer to listen on port 8125.

I hope you never write code like this in real situations, but it does show the flexibility of the syntax and the potential brevity of the language. Let's be a lot more explicit about our code. The following rewrite should make it a lot easier to understand and maintain.

var http = require('http');
var server = http.createServer();
var handleReq = function(req,res){
  res.writeHead(200, {});
  res.end('hello world');
};
server.on('request', handleReq);
server.listen(8125);

        

This example implements the minimal web server again. However, we've started assigning things to named variables. This not only makes the code easier to read than when it's chained, but also means you can reuse it. For example, it's not uncommon to use http more than once in a file. You want to have both an HTTP server and an HTTP client, so reusing the module object is really helpful. While JavaScript doesn't force you to think about memory, it doesn't mean you should thoughtlessly litter unnecessary objects everywhere. So rather than use an anonymous callback, I've named the function that handles the request event. This is less about memory usage and more about readability. I'm not saying you shouldn't use anonymous functions, but if you can lay out your code so it's easy to find, that helps a lot when maintaining it.

Because we didn't pass the request event listener as part of the factory method for the http Server object, we need to add an event listener explicitly. Calling the on method from EventEmitter does this. Finally, as with the previous example, we call the listen method with the port we want to listen on. The http Class provides other functions, but this example illustrates the most important ones.

The http server supports a number of events, which are associated with either the TCP or HTTP connection to the client. The connection and close events indicate the build-up or tear-down of a TCP connection to a client. It's important to remember that some clients will be using HTTP 1.1, which supports keep-alive. This means that their TCP connections may remain open across multiple HTTP requests.

The request, checkContinue, upgrade, and clientError events are associated with HTTP requests. We've already used the request event, which signals a new HTTP request.

The checkContinue event indicates a special event. It allows you to take more direct control of an HTTP request in which the client streams chunks of data to the server. As the client sends data to the server, it will check whether it can continue, at which point this event will fire. If an event handler is created for this event, the request event will not be emitted.

The upgrade event is emitted when a client asks for a protocol upgrade. The http server will deny HTTP upgrade requests unless there is an event handler for this event.

Finally, the clientError event passes on error events sent by the client.

The HTTP server can throw a few events. The most common one is request but you can also get events associated with the TCP connection for the request as well as other parts of the request life-cycle.

When a new TCP stream is created for a request, a connection event is emitted. This event passes the TCP stream for the request as a parameter. The stream is also available as a request.connection variable for each request that happens through it. However, only one connection event will be emitted for each stream. This means tat many requests can happen from a client with only one connection event.

Node is also great when you want to make outgoing HTTP connections. This is useful in many contexts, such as using Web Services, connecting to document store databases, or just scraping web sites. You can use the same http module when doing HTTP requests, but should use the http.ClientRequest class. There are two factory methods for this class: a general purpose one and a convenience method. Let's take a look at the general purpose case:

      var http = require('http');

var opts = {
  host: 'www.google.com'
  port: 80,
  path: '/',
  method: 'GET'
};

var req = http.request(opts, function(res) {
  console.log(res);
  res.on('data', function(data) {
    console.log(data);
  });
});

req.end();

        

The first thing you can see is that an options object defines a lot of the functionality of the request. We must provide the host name (although an IP address is also acceptable), the port, and the path. The method is optional and defaults to a value of GET if none is specified. In essence, the example is specifying that the request should be an HTTP GET request to http://www.google.com/ on port 80.

The next thing we do is use the options object to construct an instance of http.ClientRequest using the factory method http.request(). This method takes an options object and an optional callback argument. The passed callback listens to the response event. When a response event is received, we can process the results of the request. In the previous example, we simply output the response object to the console. However, it's important to notice that the body of the HTTP request is actually received via a stream in the response object. As such, you can subscribe to the data event of the response object to get the data as it becomes available.

The final important point to notice is that we had to end() the request. Since this was a GET request, we didn't write any data to the server, but for other HTTP methods, such as PUT or POST, you may need to. Until we call the end() method, request won't initiate the HTTP request because it doesn't know whether it should still be waiting for us to send data.

        var http = require('http');

var opts = {
  host: 'www.google.com'
  port: 80,
  path: '/',
};

var req = http.get(opts, function(res) {
  console.log(res);
  res.on('data', function(data) {
    console.log(data);
  });
});

          

        > var http = require('http');
> var req = http.get({host:'www.google.com', port:80, path:'/'}, function(res) { console.log(res); res.on('data', function(c) { console.log(c); }); });
> <Buffer 3c 21 64 6f 63 74 79 70

...

65 2e 73 74>
<Buffer 61 72 74 54 69

...

69 70 74 3e>

>
> var req = http.get({host:'www.google.com', port:80, path:'/'}, function(res) { res.setEncoding('utf8'); res.on('data', function(c) { console.log(c); }); });
> <!doctype html><html><head><meta http-equiv="content-type

...

load.t.prt=(f=(new Date).getTime());
})();
</script>

>

          

        var options = {
  host: 'www.example.com',
  port: 80,
  path: '/submit',
  method: 'POST'
};

var req = http.request(options, function(res) {
  res.setEncoding('utf8');
  res.on('data', function (chunk) {
    console.log('BODY: ' + chunk);
  });
});

req.write("my data");
req.write("more of my data");

req.end();

          

The URL module provides tools for easily parsing and dealing with URL strings. It's extremely useful if you have to deal with URLs. The module offers three methods: parse, format, and resolve. Let's start by looking at an example of parse using Node REPL.

> var URL = require('url');
> var myUrl = "http://www.nodejs.org/some/url/?with=query&param=that&are=awesome#alsoahash";
> myUrl
'http://www.nodejs.org/some/url/?with=query&param=that&are=awesome#alsoahash'
> parsedUrl = URL.parse(myUrl);
{ href: 'http://www.nodejs.org/some/url/?with=query&param=that&are=awesome#alsoahash'
, protocol: 'http:'
, slashes: true
, host: 'www.nodejs.org'
, hostname: 'www.nodejs.org'
, hash: '#alsoahash'
, search: '?with=query&param=that&are=awesome'
, query: 'with=query&param=that&are=awesome'
, pathname: '/some/url/'
}
> parsedUrl = URL.parse(myUrl, true);
{ href: 'http://www.nodejs.org/some/url/?with=query&param=that&are=awesome#alsoahash'
, protocol: 'http:'
, slashes: true
, host: 'www.nodejs.org'
, hostname: 'www.nodejs.org'
, hash: '#alsoahash'
, search: '?with=query&param=that&are=awesome'
, query:
   { with: 'query'
   , param: 'that'
   , are: 'awesome'
   }
, pathname: '/some/url/'
}
> 

        

The first thing we do, of course, is to require the URL module. Note that the names of modules are always lowercase. I've created a url as a string containing all the parts that will be parsed out. Parsing is really easy: we just call the parse method from the URL module on the string. It returns a data structure representing the parts of the parsed URL. The components it produces are:

The href is the full URL that was originally passed to parse. The protocol is the protocol used in the URL: e.g., http://, https://, ftp://, etc. host is the fully qualified hostname of the URL. This could be as simple as hostname for a local server, such as print server, or a fully qualified domain name such as www.google.com. It might also include a port number, such as 8080, or username and password credentials like un:pw@ftpserver.com. The various parts of the hostname are broken down further into auth, containing just the user credentials, port containing just the port, and hostname containing the hostname portion of the URL. An important thing to know about hostname is that it is still the full hostname including the top level domain (TLD, e.g. .com, .net, etc) and the specific server. If the URL was http://sport.yahoo.com/nhl, hostname would not give you just the TLD (yahoo.com) or just the host sport) but the entire hostname sport.yahoo.com. The url module doesn't have the capability to split the hostname down into its components such as domain or TLD.

The next set of components of the URL relate to everything after the host. The pathname is the entire file path after the host. In http://sports.yahoo.com/nhl, it would be /nhl. The next component is the search component. It stores the HTTP GET parameters in the URL. For example, if the URL was http://mydomain.com/?foo=bar&baz=qux, the search component would be ?foo=bar&baz=qux. Note the inclusion of the ?. The query parameter is similar to the search component. It contains one of two things, depending how parse was called.

parse takes two arguments: the url string and an optional Boolean that determines whether the queryString should be parsed using the querystring module, discussed in the next section. If the second argument is false, query will just contain a string similar to that of search but without the leading ?. If you don't pass anything for the second argument, it defaults to false.

The final component is the fragment portion of the URL. This is the part of the URL after the #. Commonly, this is used to refer to named anchors in HTML pages. For instance, http://abook.com/#chapter2 might refer to the second chapter on a web page hosting a whole book. The hash component in this case would contain #chapter2. Again note the included # in the string. Some sites, such as http://twitter.com, use more complex fragments for AJAX applications, but the same rules apply. So the URL for the Twitter mentions account, http://twitter.com/#!/mentions would have a pathname of / but a hash of #!/mentions.

The querystring module is a very simple helper module to deal with query strings. As discussed in the previous section, query strings are the parameters encoded at the end of a URL. However, when reported back as just a JavaScript string, the parameters are fiddly to deal with. The querystring module provides an easy way to create objects from the query strings. The main methods it offers are parse and decode, but some internal helper functions such as escape, unescape, unescapeBuffer, encode, and stringify are also exposed. If you have a query string, you can use parse to turn it into an object:

> var qs = require('querystring');
> qs.parse('a=1&b=2&c=d');
{ a: '1', b: '2', c: 'd' }
> 

          

Here, the class's parse function turns the querystring into an object in which the properties are the keys and the values correspond to the ones in the query string. You should notice a few things, though. First, the numbers are returned as strings, not numbers. Since JavaScript is loosely typed and will coerce a string into a number in a numerical operation, this works pretty well. However, it's worth bearing in mind for those times when that coercion doesn't work.

Another thing it's important to be aware of is that you must pass the query string without the leading ? that demarks it in the URL. A typical URL might look like http://www.bobsdiscount.com/?item=304&location=san+francisco. The querystring starts with a ? to indicate where the filepath ends, but if you include the ? in the string you pass to parse, the first key will start with a ?, which is almost certainly not what you want.

This library is really useful in a bunch of contexts. Query strings are used outside of URLs. When you get content from an HTTP POST that is x-form-encoded, it will also be in query string form. All the browser manufacturers have standardized around this approach. By default, forms in HTML will send data to the server in this way also.

The querystring module is also used as a helper module to the url module. Specifically when decoding URLs you can ask URL to turn the querystring into an object for you rather than just a string. That's described in more detail in the previous section, but the parsing that is done is using the parse method from querystring.

Another important part of querystring is encode. This function takes a queryString key/value pair object and stringifies it. This is really useful when working with HTTP requests, especially POST data. It makes it easy to work with a JavaScript object until you need to send the data over the wire and then simply to encode it at that point. Any JavaScript object can be used however you should ideally use an object which only has the data in it you want because the encode method will add all properties of the object. However if the property value isn't a string, boolean or number won't serialized and the key will just be included with an empty value.

> var myObj = {'a':1, 'b':5, 'c':'cats', 'func': function(){console.log('dogs')}}
> qs.encode(myObj);
'a=1&b=5&c=cats&func='
> 

          

Many components in Node provide continuous output or can process continuous input. To make these components act in a consistent way, the stream API provides an abstract interface for them. This API provides common methods and properties that are available in specific implementation of streams. Streams can be readable, writable, or both. All streams are EventEmitter instances, allowing them to emit events.

var fs = require('fs');
var filehandle = fs.readFile('data.txt', function(err, data) {
  console.log(data)
});

            

          //abstract stream
var spool = "";
stream.on('data', function(data) {
  spool += data;
});
stream.on('end', function() {
  console.log(spool);
});

            

Filesystem is obviously a very helpful module because you need it in order to access files on disk. It closely mimics the POSIX style of file I/O. It is a somewhat unique module in that all of the methods have both asynchronous and synchronous versions. However, I strongly recommend that you use the asynchronous methods unless you are building command line scripts with Node. Even then, it is often much better to use the async versions, even though doing so adds a little extra code, so that you can access multiple files in parallel and reduce the running time of your script.

The main issue that people face while dealing with asynchronous calls is ordering, and this is especially true with file I/O. It's common to want to do a number of moves, renames, copies, reads, or writes at one time. However, if one of the operations depends on another then this can create issues because return order is not guaranteed. This means that the first operation in the code happens after the second operation in the code. Patterns exist to deal make ordering easy. They are talked about in detail in chapter 4 but we'll recap here as well.

An example of this might be reading and then deleting a file. If the delete (unlink) happens before the read, it will be impossible to read the content of the file.

var fs = require('fs');

fs.readFile('warandpeace.txt', function(e, data) {
  console.log('War and Peace: ' + data);
});

fs.unlink('warandpeace.txt');

          

Notice that we are using the asynchronous methods, and while we have created callbacks we haven't written any code that defines which order they get called in. This often becomes a problem for programmers not used to programming in event loops. This code looks OK on the surface and sometimes it will work at runtime, but sometimes it won't. Instead, we need to use a pattern in which we specify the ordering we want for the calls. There are a few approaches. One common approach is to use nested callbacks. In the following example the asynchronous call to delete the file is nested within the callback to the asynchronous function that reads the file.

var fs = require('fs');

fs.readFile('warandpeace.txt', function(e, data) {
  console.log('War and Peace: ' + data);
  fs.unlink('warandpeace.txt');
});

          

This approach is often a very effective one for discrete sets of operations. In our example with just two operations, it's easy to read and understand. This pattern can get out of control though.

Although Node is JavaScript, it is JavaScript out its usual environment. For instance, the browser requires JavaScript to perform many functions, but manipulating binary data is rarely one of them. While JavaScript does support bitwise operations, it doesn't have a native representation of binary data. This is especially troublesome when one also considers the limitations of the number type system in JavaScript, which might otherwise lend itself to binary representation. Node introduces the Buffer class to make up for this shortfall when working with binary data is often essential.

Buffers are an extension to the V8 engine, which means that they have their own set of pitfalls. Buffers are actually a direct allocation of memory, which may mean a little or a lot depending on your experience with lower level computer languages. Unlike the data types in JavaScript, which abstract some of the ugliness of storing data, Buffer provides direct memory access warts and all. Once a Buffer is created, it is a fixed size. If you want to add more data, you must clone the Buffer into a larger Buffer. Although some of these features may seem frustrating, they allow Buffer to perform at the speed necessary for many data operations on the server. This was a conscious design choice, to trade off some programmer convenience for performance.

128 64 32 16 8 4 2 1
--- -- -- -- - - - -
0   0  0  0  0 0 0 0 = 0

128 64 32 16 8 4 2 1
--- -- -- -- - - - -
1   1  1  1  1 1 1 1 = 255

128 64 32 16 8 4 2 1
--- -- -- -- - - - -
1   0  0  1  0 1 0 1 = 149

            

Hex to Decimal:

0 1 2 3 4 5 6 7 8 9 A  B  C  D  E  F
- - - - - - - - - - -- -- -- -- -- --
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15


Counting in hex:

16 1
-- -
0  0 = 0

16 1
-- -
F  F = 255

16 1
-- -
9  5 = 149

            

> new Buffer([255,0,149]);
<Buffer ff 00 95>
> 

            

> new Buffer(10);
<Buffer e1 43 17 05 01 00 00 00 41 90>
> 

          

> new Buffer('foobarbaz');
<Buffer 66 6f 6f 62 61 72 62 61 7a>
> new Buffer('foobarbaz', 'ascii');
<Buffer 66 6f 6f 62 61 72 62 61 7a>
> new Buffer('foobarbaz', 'utf8');
<Buffer 66 6f 6f 62 61 72 62 61 7a>
> new Buffer('é');
<Buffer c3 a9>
> new Buffer('é', 'utf8');
<Buffer c3 a9>
> new Buffer('é', 'ascii');
<Buffer e9>
> 

          

          > var b = new Buffer(1);
> b
<Buffer 00>
> b.write('a');
1
> b
<Buffer 61>
> b.write('é');
0
> b
<Buffer 61>
> 

            

          > var b = new Buffer(5);
> b.write('fffff');
5
> b
<Buffer 66 66 66 66 66>
> b.write('ab', 1);
2
> b
<Buffer 66 61 62 00 66>
> 

            

Borrowed from the Firebug debugger in Firefox, this simple command allows you to easily output to STDOUT without using any modules. It also does some pretty printing functionality to help enumerate objects.

> foo = {};
{}
> foo.bar = function() {1+1};
[Function]
> console.log(foo);
{ bar: [Function] }
>