Node.js has a fully featured event system that we can easily inherit from and implement. We do not need any extra frameworks or custom code. EventEmitter is the class to inherit from, and we will get every function in the rest of this section available.

Here is an example of setting up a custom the EventEmitter parameter:

var util = require('util');
var events = require('events');

function MyEventEmitter(){
    events.EventEmitter.call(this);
    this.test = function (emitThis) {
        this.emit('testEvent', emitThis);
    }
}

util.inherits(MyEventEmitter, events.EventEmitter);

var myEE = new MyEventEmitter();

myEE.on('testEvent', function (data) { console.log(data) });

myEE.test('test');

The on function has become the preferred naming convention to add listeners to events. As an example, jQuery uses the exact same function name for their event listeners. The event handler is a string name of the event that will be emitted. The listenerFunction parameter is what will be executed when the event is emitted.

The listenerFunction parameter can be an anonymous function or a reference to a function. The preferred way of adding a listener is with a reference to a function. This will allow us to remove this specific listener at a later time.

Here is an example based on our new MyEventEmitter class:

var quickLog = function (data) {
    console.log('quickLog: ' + data);
}
myEE.on('testEvent', quickLog);

When we are done listening for this event, we will want to remove our listener. This will help prevent memory leaks. If we added an anonymous function as the listener, then we cannot remove it as we do not have a reference to it. Using our previous example from on, we will remove the listener:

myEE.removeListener('testEvent', quickLog);

This is essentially the nuclear option to remove listeners. This is indiscriminate with listeners. The removeAllListeners parameter will even remove listeners we did not add. Use this as a last resort.

An example that removes all the listeners from this event is shown here. If the event was left blank, it would remove all listeners for all events:

myEE.removeAllListeners('testEvent');

The algorithms that can be used will be different for each system as it relies on OpenSSL. We can find out the algorithms that crypto can use by calling crypto.getHashes(). This will return an array of strings that can then be passed into createHash as the algorithm.

The return object from this function is a crypto.Hash object, which is covered in the next section.

Here is an example that creates an MD5 hash:

var md5 = crypto.createHash('md5');

Once we get a reference to the Hash object that has been returned, you will see that it has two functions. The first is update, which allows us to add to the data that will be hashed. This can be called multiple times. This is important if we want to hash a stream input.

The next function is digest. This will return digest based on the algorithm the hash object was created with. The string encoding for this function can be hex, binary, or BASE64.

Here is a full example of reading data from a file and then calculating the MD5 hash of the file.

var f = file.readFileSync(__dirname + '/test.txt');

var md5 = crypto.createHash('md5');
md5.update(f);
console.log(md5.digest('base64'));

Both pbkdf2 and pbkdf2Sync will return a derived key as a buffer.

Pbkdf2 (password-based key derivation function 2) is designed for password storage. It is better than hashing because it is difficult. Hashing is designed to be a quick calculation. This is bad because modern CPUs can calculate thousands upon thousands of hashes a second. This makes cracking a hashed password easy.

Pbkdf2 fixes this using a work factor in iterations. The higher the iterations, the longer the calculation will take. Now, instead of calculating thousands a second, we can slow a CPU down to just a few a second. This is a significant decrease.

These are the parameters used:

Here is an example of creating a derived key for the string password and salt:

crypto.pbkdf2('password', 'salt', 10000, 32, function (err, key) {
    console.log(key.toString('base64'));
});

A buffer is returned.

Random data is needed for various functions. While no data can truly be random, there are varying levels of randomness. The randomBytes parameter is random enough to use for cryptographic functions. A perfect use of randomBytes is for a salt to be used in pbkdf2. The salt variable is combined with the password to create a different hash even if the passwords are the same.

This function can be executed asynchronously or synchronously. It depends on whether there is a callback, which it would then execute asynchronously.

Here is a function to create a random salt for pbkdf2. If you compare this example to the previous one, you will see that this example outputs a unique string each time, while the previous one does not:

var random = crypto.randomBytes(256);

crypto.pbkdf2('password', random.toString('base64'), 10000, 32, function (err, key) {
    console.log(key.toString('base64'));
});

A buffer is returned.

This functions exactly like randomBytes, except it is not cryptographically strong. This means that we should not use it with any cryptographic functions such as pbkdf2.

We can use it for anything else that requires randomness, a filename, or a cache key for example.

Here is a simple example of executing this function asynchronously:

crypto.pseudoRandomBytes(256, function (err, randomData) {
    console.log(randomData.toString('base64'));
});

This returns a buffer object.

There are three different ways to initialize a buffer. The first function uses an integer of the given size, the next one uses an array, and the final method can use just a string. The encoding is optional, as it defaults to UFT8.

This example demonstrates initializing using an array with the hello string in ASCII:

var hello = [72, 101, 108, 108, 111];
var buffer = new Buffer(hello);
console.log(buffer.toString('ascii'));

This returns the value at the index.

This works much like an array. Here is an example of getting the first index in the buffer:

var buffer = new Buffer('Hello!');
console.log(buffer[0]);

This returns a string.

This is most likely the function that you will use to get the data out of a buffer. The first parameter is encoding, which is one of the following:

All the parameters are optional, so this means that they all have default values. Encoding is defaulted to UTF8, start is 0, and end is the end of the buffer.

Here is an example of creating a buffer and retrieving the data out of it. It explicitly defines each of the parameters:

var buffer = new Buffer('Hello this is a buffer');
console.log(buffer.toString('utf8', 0, buffer.length));

This returns an array with the contents of the buffer.

This will return contents of the buffer mapped to an array. This example is similar to the previous example, but with toJSON:

var buffer = new Buffer('Hello this is a buffer');
console.log(buffer.toJSON());

This returns a Boolean value.

Remember that this is a class method, so it can be executed without a new instance of buffer. Here is an example of using the function:

var buffer = new Buffer('Hello this is a buffer');
console.log(Buffer.isBuffer(buffer));

This returns an integer of the number of bytes written.

This function will write the string passed into the buffer. Much like the other buffer functions, there are many optional parameters that have defaults. The default offset is 0, the length is buffer.length – offset, and the encoding is UTF8.

This example writes to a buffer twice using the return value from the first write to append the second string:

var buffer = new Buffer(12);
var written = buffer.write('Buffer ', 0, 7, 'utf8');
console.log(written);
buffer.write('time.', written);
console.log(buffer.toString());

This returns an integer of the number of bytes needed.

Buffers cannot be resized after initializing, so we may need to know how big a string is beforehand. This is where byteLength comes in.

Here is an example that determines the size of a string and then writes it to the buffer:

var byteLength = Buffer.byteLength('Buffer time.', 'utf8');
var buffer = new Buffer(byteLength);
var written = buffer.write('Buffer time.', 0, buffer.length, 'utf8');
console.log(buffer.toString());

This returns an unsigned integer of the size used, 8 for readUInt8.

Not all data stored in a buffer is exactly a byte. Sometimes, data will need to be read in 16-bit or 32-bit chunks. In addition to this, you can also specify whether the data is little endian or big endian, denoted by LE or BE in the function name, respectively.

The offset is which spot in the buffer to start at. The noAssert parameter will run validation if the offset size is in the buffer. By default, it is false.

Here is an example of setting data and then reading the data out with readUInt16:

var buffer = new Buffer(2);
buffer[0] = 0x1;
buffer[1] = 0x2;
console.log(buffer.readUInt16LE(0));
console.log(buffer.readUInt16BE(0));

This is the exact opposite of the readUInt function. Sometimes, we need to write data that is larger than one byte in length. These functions make it simple.

The noAssert parameter is optional, and it defaults to false. This will not run any validation on the value or offset.

Here is an example of writing UInt16 to the buffer:

var buffer = new Buffer(4);
buffer.writeUInt16LE(0x0001, 0);
buffer.writeUInt16LE(0x0002, 2);
console.log(buffer);

This is probably the most used console function. It is great for debugging, and the output can be combined with piping to write to a file for a history. The multiple parameters create a string-like function.

Here is an example of using multiple parameters:

console.log('Multiple parameters in %s', 'console.log');

Many times, the output of console.log and console.dir will be similar. However, when trying to look at an object, console.dir should be preferred.

These two functions will always be used together. The console.time parameter will start a timer that can be stopped with console.timeEnd by passing the same label. When timeEnd is called, it will log the elapsed time between start and end in milliseconds.

Here is an example that uses setTimeout:

console.time('simple-timer');
setTimeout(function () {
    console.timeEnd('simple-timer');
}, 500);

This works much like console.log. The first parameter can be treated like a formatted string, with the other parameters supplying the additional input. The main difference is that console.trace will include a stack trace when it logs to the console.

Here is a simple example:

console.trace('This should be the first line.');

An interactive console session will ask you quite a few questions and use the answers to build a package.json file for you. This is a great way to kick off a new module. This will not delete your current the package.json file or any of the current properties if the package.json file exists.

This is not a function or command, but it is the most important file in your project. It is what determines all the information about your project. Although technically, the only properties needed are name and version, there are many properties that can be set. If this file was created using npm in it, you will have quite a few already filled out. It would be tedious to list out all the possibilities. Here are just a few of the most useful: name, version, scripts, dependencies, devDependencies, authors, and license.

The npm docs at https://www.npmjs.org/doc/files/package.json.html go through all the settings their uses.

This is the main way to install new packages and their dependencies. If npm install is called without any parameters, it will use package.json and install all the dependencies.

This command also allows you to install packages by executing it with the name of the package. This can be augmented by adding a version. If the version is omitted, it will install the newest version. In addition to this, you can use save flags that create a property in dependencies or devDependcies.

This is not the entire list of what npm install can do, but it is the most used list.

This command will update all the packages or a specific package to the newest version.

This is different from the basic list of dependencies in package.json. Most packages have requirements of their own. When a package is installed, npm will go out and find the newest version that matches the dependency's specified version. This can lead to different versions of packages installed when run at different times. This is something that most developers want to avoid.

One way to combat this is to run npm shrinkwrap. It will create npm-shrinkwrap.json. This file will explicitly define the versions currently installed recursively for every package installed. This ensures that when you run npm install again, you will know what package versions will get installed.

The package.json file has a property named scripts. This is an object that can have a list of commands that can be run by npm. These scripts can be anything that runs from the command line.

There are three commands on npm that use these scripts objects. These are npm test, npm start, and npm stop. These commands map to test, start, and stop the scripts object, respectively.

Here is an example for a scripts object from package.json and the way to call it from npm:

package.json:
  "scripts": {
    "hey":  "echo hey"
}
npm run hey

Use with a non-flowing readable stream:

readable.read([size])

readable.on('readable', function () {
    var chunk;
   while (chunk = readable.read()) {
        console.log(chunk.toString());
    }
});

This sets the encoding of the stream:

stream.setEncoding(encoding)

readable.setEncoding('utf8');
readable.on('readable', function () {
    var chunk;
   while (chunk = readable.read()) {
        console.log(chunk);
    }
});

These functions pause and resume a stream:

stream.pause()
stream.resume()

readable.pause();
readable.on('data', function (chunk) {
    console.log(chunk.toString());
});
setTimeout(function () { readable.resume();}, 3000);

This allows you to take the output of a readable stream and send it to the input of a writable stream:

readable.pipe(writable, [options])

var readable = fs.createReadStream('test.txt');
readable.pipe(process.stdout);

This function writes to the stream:

writable.write(chunk, [encoding], [callback])

var fs = require('fs');
var writable = fs.createWriteStream('WriteStream.txt');

var hasWritten = writable.write('Write this!', 'utf8', function () {
    console.log('The buffer has written');
});
end

writable.end([chunk], [encoding], [callback])

var fs = require('fs');
var writable = fs.createWriteStream('WriteStream.txt');

writable.end('Last data written.', 'utf8', function () {
    //this runs when everything has been written.
});