Modules are now a supported language-level feature. They allow developers to wrap their component in a Module pattern, and export and import modules inside their code. The implementation is very similar to the CommonJS module implementation described in the previous chapters, although ES2015 modules also support asynchronous loading. The basic keywords for working with ES2015 modules are export and import. Let's look at a simple example. Suppose you have a file named lib.js that contains the following code:

export function halfOf(x) {
    return x / 2;
}

So, in your main.js file, you can use the following code:

import halfOf from 'lib';
console.log(halfOf(84));

However, modules can be much more fun. For instance, let's say our lib.js file looks like this:

export function halfOf(x) {
    return x / 2;
}
export function multiply(x, y) {
    return x * y;
}

In your main file, use the following code:

import {halfOf, multiply} from 'lib';
console.log(halfOf(84));
console.log(multiply(21, 2));

ES2015 modules also support default export values. So, for instance, let's say you have file named doSomething.js that contains the following code:

export default function () { 
    console.log('I did something')
};

You'll be able to use it as follows in your main.js file:

import doSomething from 'doSomething';
doSomething();

It is important to remember that the default import should identify their entities using the module name.

Another important thing to remember is that modules export bindings and not values. So for instance, let's say you have a validator.js file that looks like this:

export let flag = false;
export function touch() {
    flag = true;
}

You also have a main.js file that looks like this:

import { flag, touch } from 'validator';
console.log(flag); 
touch();
console.log(flag); 

The first output would be false, and the second would be true. Now that we have a basic understanding of modules, let's move to classes.

The long debate about classes versus prototypes came to a conclusion that classes in ES2015 are basically just a syntactic sugar over the prototype-based inheritance. Classes are easy-to-use patterns that support instance and static members, constructors, and super calls. Here is an example:

class Vehicle {
    constructor(wheels) {
        this.wheels = wheels;
    }
    toString() {
        return '(' + this.wheels + ')';
    }
}

class Car extends Vehicle {
    constructor(color) {
        super(4);
        this.color = color;
    }
    toString() {
        return super.toString() + ' colored:  ' + this.color;
    }
}

let car = new Car('blue');
car.toString(); 

console.log(car instanceof Car); 
console.log(car instanceof Vehicle); 

In this example, the Car class extends the Vehicle class. Thus, the output is as follows:

 (4) in blue
true
true

Arrows are functions shorthand by the => syntax. For people familiar with other languages such as C# and Java 8, they might look familiar. However, arrows are also very helpful because they share the same lexical this as their scope. They are mainly used in two forms. One is using an expression body:

const squares = numbers.map(n => n * n); 

Another form is using a statement body:

numbers.forEach(n => {
  if (n % 2 === 0) evens.push(n);
});

An example of using the shared lexical would be:

const author = {
  fullName: "Bob Alice",
  books: [],
  printBooks() {
     this.books.forEach(book => console.log(book + ' by ' + this.fullName));
  }
};

If used as a regular function, this would be the book object and not the author.

Let and Const are new keywords used for symbol declaration. Let is almost identical to the var keyword, so it'll behave the same as global and function variables. However, let behaves differently inside a block. For instance, look at the following code:

function iterateVar() {
  for(var i = 0; i < 10; i++) {
    console.log(i);
  }

  console.log(i)
}

function iterateLet() {
  for(let i = 0; i < 10; i++) {
    console.log(i);
  }
  
  console.log(i)
}

The first function will print i after the loop, but the second one will throw an error, since i is defined by let.

The const keyword forces single assignment. So, this code will throw an error as well:

const me = 1
me = 2

Default, Rest, and Spread are three new features related to functions parameters. The default feature allows you to set a default value to the function parameter:

function add(x, y = 0) {
    return x + y;
}
add(1) 
add(1,2)

In this example, the value of y will be set to 0 if a value is not passed or is set to undefined.

The Rest feature allows you to pass an array as trailing arguments as follows:

function userFriends(user, ...friends) {
  console.log(user + ' has ' + friends.length + ' friends');
}
userFriends('User', 'Bob', 'Alice');

The Spread feature turns an array into a call argument:

function userTopFriends(firstFriend, secondFriend, thirdFriends) {
  console.log(firstFriend);
  console.log(secondFriend);
  console.log(thirdFriends);
}

userTopFriends(...['Alice', 'Bob', 'Michelle']);

Going into modern web development, ES2015 will become a viable part of your daily programming sessions. What is shown here is the tip of the iceberg, and it is strongly recommended that you continue to investigate it deeper. However, for the purposes of this book, it will suffice.

Once you have downloaded the right version, run the .msi file. MongoDB should be installed in the C:\Program Files\MongoDB\ folder. While running, MongoDB uses a default folder to store its data files. On Windows, the default folder location is C:\data\db. So, in the command prompt, go to C:\ and issue the following command:

> md c:\data\db

Once you've finished creating the data folders, you'll get two options while running the main MongoDB service.

Running MongoDB manually

To run MongoDB manually, you will need to run the mongod binary. So, open the command prompt and navigate to the C:\Program Files\MongoDB\Server\3.2\bin folder. Then, issue the following command:

C:\Program Files\MongoDB\Server\3.2\bin> mongod

The preceding command will run the main MongoDB service that starts listening to the default 27017 port. If everything goes well, you should see a console output similar to the following screenshot:

Running the MongoDB server on Windows

Depending on the Windows security level, a security alert dialog, which notifies you about the blocking of some service features, will be issued. If this occurs, select a private network and click on Allow Access.

Note

You should be aware that the MongoDB service is self-contained, so you can alternatively run it from any folder of your choice.

> md C:\data\log

systemLog:
    destination: file
    path: c:\data\log\mongod.log
storage:
    dbPath: c:\data\db

> sc stop MongoDB
> sc delete MongoDB

> "C:\Program Files\MongoDB\Server\3.2\bin\mongod.exe" --config "C:\Program Files\MongoDB\Server\3.2\mongod.cfg" --install

> net start MongoDB

In this section, you'll learn the different ways of installing MongoDB on Unix-based operating systems. Let's begin with the simplest way to install MongoDB, which involves downloading MongoDB's precompiled binaries.

You can download the right version of MongoDB using the download page at http://www.mongodb.org/downloads. Alternatively, you can do this via CURL by executing the following command:

$ curl -O http://downloads.mongodb.org/osx/mongodb-osx-x86_64-3.2.10.tgz

Notice that we have downloaded the Mac OS X 64-bit version, so make sure you alter the command to fit the version suitable for your machine. After the downloading process is over, unpack the file by issuing the following command in your command-line tool:

$ tar -zxvf mongodb-osx-x86_64-3.2.10.tgz

Now, change the name of the extracted folder to a simpler folder name by running the following command:

$ mv mongodb-osx-x86_64-3.2.10 mongodb

MongoDB uses a default folder to store its files. On Linux and Mac OS X, the default location is /data/db, so in your command-line tool, run the following command:

$ mkdir -p /data/db

The preceding command will create the data and db folders, because the –p flag creates parent folders as well. Notice that the default folder is located outside your home folder, so make sure you set the folder permission by running the following command:

$ chown -R $USER /data/db

Now that you have everything prepared, use your command-line tool and go to the bin folder to run the mongod service as follows:

$ cd mongodb/bin
$ mongod

This will run the main MongoDB service, which will start listening to the default 27017 port. If everything goes well, you should see a console output similar to the following screenshot:

Running the MongoDB server on Mac OS X

The MongoDB archive file includes the MongoDB shell, which allows to you to interact with your server instance using the command line. To start the shell, navigate to the MongoDB bin folder and run the mongo service as follows:

$ cd mongodb/bin
$ mongo

If you successfully installed MongoDB, the shell will automatically connect to your local instance, using the test database. You should see a console output similar to the following screenshot:

Running the MongoDB shell on Mac OS X

To test your database, run the following command:

> db.articles.insert({title: "Hello World"})

The preceding command will create a new article collection and insert a JSON object containing a title property. To retrieve the article object, execute the following command:

> db.articles.find()

The console will output a text similar to the following message:

{ _id: ObjectId("52d02240e4b01d67d71ad577"), title: "Hello World" }

Congratulations! This means your MongoDB instance is working properly, and you have successfully managed to interact with it using the MongoDB shell. In the upcoming chapters, you'll learn more about MongoDB and how to use the MongoDB shell.

Installing Node.js on a Windows machine is a simple task that can be easily accomplished using the standalone installer. To begin with, navigate to https://nodejs.org/en/download/ and download the right .msi file. Notice there are 32-bit and 64-bit versions, so make sure you download the right one for your system.

After downloading the installer, run it. If you get any security dialog boxes, just click on the Run button, and the installation wizard should start. You will be prompted with an installation screen similar to the following screenshot:

Node.js Windows installation wizard

Once you click on the Next button, the installation should begin. A few moments later, you'll see a confirmation screen similar to the following screenshot, telling you that Node.js was successfully installed:

Node.js Windows installation confirmation

Installing Node.js on Mac OS X is a simple task that can be easily accomplished using the standalone installer. Start by navigating to the https://nodejs.org/en/download/ page and download the .pkg file. After downloading the installer, run it, and you will be prompted with an installation screen similar to the following screenshot:

Node.js Mac OS X installation wizard

Click on Continue, and the installation process should begin. The installer will ask you to confirm the license agreement and then ask you to select the folder destination. Choose the option most suitable for you before clicking on the Continue button again. The installer will then ask you to confirm the installation information and ask you for your user password. A few moments later, you'll see a confirmation screen similar to the following screenshot, telling you that Node.js was successfully installed:

Node.js Mac OS X installation confirmation

To install Node.js on a Linux machine, you'll have to use the tarball file from the official website. The best way of doing so is to download the latest version and then build and install the source code using the make command. Start by navigating to the http://nodejs.org/en/download/ page, and download the suitable .tar.gz file. Then, expand the file and install Node.js by issuing the following commands:

$ tar -zxf node-v6.9.1.tar.gz
$ cd node-v6.9.1
$ ./configure && make && sudo make install

If everything goes well, the commands will install Node.js on your machine. Note that these commands are for the Node.js 6.9.1 version, so remember to replace the version number with the version you downloaded.

After you have successfully installed Node.js, you will be able to start experimenting with it using the provided command-line interface (CLI). Go to your command-line tool and execute the following command:

$ node

This will start the Node.js CLI, which will wait for a JavaScript input. To test the installation, run the following command:

> console.log('Node is up and running!');

The output should be similar to the one that follows:

Node is up and running!
undefined

This is nice, but you should also try to execute a JavaScript file. Start by creating a file named application.js that contains the following code:

console.log('Node is up and running!');

To run it, you'll have to pass the file name as the first argument to the Node CLI by issuing the following command:

$ node application.js
Node is up and running!

Congratulations! You have just created your first Node.js application. To stop the CLI, press CTRL + D or CTRL + C.

To understand how npm works, we will install the Express web framework module, which you'll use in the upcoming chapters. npm is a robust package manager, which keeps a centralized registry for public modules. To browse the available public packages, visit the official website at https://www.npmjs.com/.

Most of the packages in the registry are open source and contributed by the Node.js community developers. When developing an open source module, the package author can decide to publish it to the central registry, allowing other developers to download and use it in their projects. In the package configuration file, the author will choose a name that will later be used as a unique identifier to download that package.

$ npm install <Package Unique Name>

$ npm install –g <Package Unique Name>

$ npm install express

$ npm install <Package Unique Name>@<Package Version>

$ npm install express@2.x 

$ npm uninstall < Package Unique Name>

$ npm uninstall –g < Package Unique Name>

$ npm update < Package Unique Name>

$ npm update –g < Package Unique Name>

Managing dependencies using the package.json file

Installing a single package is nice, but pretty soon, your application will need to use several packages. So, you'll need a better way to manage these dependencies. For this purpose, npm allows you to use a configuration file named package.json in the root folder of your application. In your package.json file, you'll be able to define various metadata properties of your application, including properties such as the name, version, and author of your application. This is also where you define your application dependencies.

The package.json file is basically a JSON file that contains the different attributes you'll need to describe your application properties. An application using the latest Express and Grunt packages will have a package.json file as follows:

{
  "name" : "MEAN",
  "version" : "0.0.1",
  "dependencies" : {
    "express" : "latest",
    "grunt" : "latest"
  }
}

Note

Your application name and version properties are required, so removing these properties will prevent npm from working properly.

Creating a package.json file

While you can manually create a package.json file, an easier approach would be to use the npm init command. To do so, use your command-line tool and issue the following command:

$ npm init

npm will ask you a few questions about your application and will automatically create a new package.json file for you. A sample process should look similar to the following screenshot:

Using npm init on Mac OS X

After creating your package.json file, you'll need to modify it and add a dependencies property. Your final package.json file should look like the following code snippet:

{
  "name": "mean",
  "version": "0.0.1",
  "description": "My First MEAN Application",
  "main": "server.js",
  "directories": {
    "test": "test"
  },
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "MongoDB",
    "Express",
    "Angular",
    "Node.js"
  ],
  "author": "Amos Haviv",
  "license": "MIT",
  "dependencies": {
    "express": "latest",
    "grunt": "latest"
  }
}

Note

In the preceding code example, we used the latest keyword to tell npm to install the latest versions of these packages. However, it is highly recommended that you use specific version numbers or range to prevent your application dependencies from changing during development cycles. This is because new package versions might not be backward compatible with older versions, which will cause major issues in your application.

Installing the package.json dependencies

After creating your package.json file, you'll be able to install your application dependencies by navigating to your application's root folder and using the npm install command, as follows:

$ npm install

npm will automatically detect your package.json file and install all your application dependencies, placing them under a local node_modules folder. An alternative and sometimes better approach to installing your dependencies is to use the following npm update command:

$ npm update

This will install any missing packages and will update all of your existing dependencies to their specified version.

Updating the package.json file

Another robust feature of the npm install command is the ability to install a new package and save the package information as a dependency in your package.json file. This can be accomplished using the --save optional flag when installing a specific package. For example, to install the latest version of Express and save it as a dependency, you can just use the following command:

$ npm install express --save

npm will install the latest version of Express and will add the Express package as a dependency to your package.json file. For clarity, in the upcoming chapters, we prefer to manually edit the package.json file. However, this useful feature can come in pretty handy in your daily development cycles.

Note

It is recommended that you learn more about npm's vast array of configuration options by visiting the official documentation at https://docs.npmjs.com/files/package.json.