Express Web Application Development: Here's a comprehensive guide to making the most of Express's flexibility in building web applications. With lots of screenshots and examples, it's the perfect step-by-step manual for those with an intermediate knowledge of JavaScript.

The best way to learn any new technology is to try it out using some practical examples. So, let's go ahead and build an Express app and find out how it works.

To ensure our experiments do not mess up our filesystem, let's create a directory named express-app in your home directory and build our app there:

$ cd ~
$ mkdir express-app
$ cd express-app

The app directory is ready and we can start building our first Express app.

{
  "name": "test-app",
  "version": "0.0.1",
  "private": true,
  "scripts": {
    "start": "node app"
  },
  "dependencies": {
    "express": "3.2.6",
    "jade": "*"
  }
}

The process of creating the manifest file, the app.js file, the views, and other directories and files can become a tedious chore as we start to work on multiple projects. To automate this process, we can use the express command-line tool.

To refresh you memory, we first encountered the express command-line tool while learning how to install Express. We were told that it generates Express app skeletons; now we have a fairly good idea what it might do.

Using its help option (-h), let's ask express how it works and what its options are:

$ express –h

  Usage: express [options] [directory]

  Options:

    -h, --help          output usage information
    -V, --version       output the version number
    -s, --sessions      add session support
    -e, --ejs           add ejs engine support (defaults to jade)
    -J, --jshtml        add jshtml engine support (defaults to jade)
    -H, --hogan         add hogan.js engine support
    -c, --css <engine>  add stylesheet...

In Chapter 1, What is Express?, we learned about Express middlewares and saw how to create one. Now, let's go find out how to include one in our app. Remember we use app.use() for including middlewares.

Though we can write our own middlewares, we will focus on using one of the middlewares that comes bundled with Express.

For your reference, the following is the list of the middlewares that are available in Express, by default:

Express does not come packed with a huge bunch of built-in libraries to perform tasks that are beyond a basic website. Express is very minimal. But that does not mean that it is not capable of performing complex tasks.

You have a huge collection of Node modules on the npm registry that can be easily plugged in to your app and used for performing all sorts of tasks in the app.

In Chapter 1, What is Express?, we were introduced to Node modules, and we learned how to write them. We also found out that they can be used to modularly extend the power and capability of Express.

You could write your own Node modules to accomplish many things, but anything you are trying to achieve, probably there is an excellent open source Node module out there already. You just need to find the right module, install it, and use it in your app.

Express comes with a built-in logging module called logger, it can be a very useful tool while you are developing the app. You enable it like any other Express module:

app.use(express.logger());

Without any options, the logger middleware will log a detailed log. You can customize the details with the following tokens in the format option of the logger middleware:

And this is how you specify the log format using the tokens:

app.use(express.logger({ format: ':remote...

We actually don't need to use an .ini file for configuring our apps, as shown in a previous example. The purpose of the example was just to show you how to use a Node module, not the recommended practice.

As a side effect of how require() works, Node supports JSON-based configuration files by default. Create a file with a JSON object describing the configurations, save it with a .json extension, and then load it in the app file using require().

Here is an example of a JSON-based config file:

{
  "development": {
    "db_host": "localhost",
    "db_user": "root",
    "db_pass": "root"
  },

  "production": {
    "db_host": "192.168.1.9",
    "db_user": "myappdb",
    "db_pass": "!p4ssw0rd#"
  }
}

This is how you would load it:

var config = require('./config.json')[app.get('env')];

Now the environment-specific configuration...

An Express application has a set of predefined application variables that are used to configure various options of the app. These variables are used for setting various dynamic aspects of the app and can be set using the app.set() method. So far we have used two of them:

app.set('view engine', 'jade');
app.set('views', './views');

The values of application variables can be retrieved using the corresponding app.get() method.

The following table lists all the options that can be configured in an Express app:

In a software release process, we designate systems for development, UAT, staging, production, and so on for different stages of product release. Technically, these contexts of application execution are called environments.

It is very common that we want our software to execute differently on different environments. For example, in a development environment, we would like to see a very verbose detail about any error our software might encounter, but we might not want to do so in the production environment. Express has a very simple mechanism to let us do that. Let's find out how it works.

Express' app.get('env') method returns the current environment of the app. Based on this value, you can configure your app to use different middlewares, Node modules, and so on; effectively changing the behavior of the app based on the environment.

Before we go about configuring our app based on its environment, let's find out how app.get('env') works.

When an Express app starts...

In this chapter, we learned how to create a fairly complete Express app from the ground up. We started by demonstrating the fact that Express are Node modules. Then we went on to create a simple app, upon which we added more and more components and features to make it more complex. By the end of the exercise, we had an app that could run on different modes depending on the environment.

We now have a good amount of knowledge to make sense of an auto-generated Express app.

Since routes are the public interfaces to an app, they make it a natural topic to focus on next. We will learn in detail about routes in Express in the next chapter.