Introduction to Node.js

last modified last modified October 18, 2023

Node.js tutorial is an introductory tutorial to Node.js. We describe Node.js and provide some Node.js code examples.

Node.js

Node.js is an open-source, cross-platform JavaScript run-time environment. It was built on Chrome's V8 JavaScript engine. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient. Node.js was originally written by Ryan Dahl in 2009.

Node.js provides a rich library of various JavaScript modules, such as fs for working with filesystem or http for working with HTTP requests and responses.

Node.js applications are written in JavaScript, and can be run within the Node.js runtime on OS X, Microsoft Windows, and Linux.

Node.js has a package manager called npm, which is a huge ecosystem of open source JavaScript libraries.

Node.js installation

We install the newest version of Node.js. Follow the installation instructions available on the Node.js website for your platform.

Node.js first example

We create a simple console application.

console.log("This is our first application");

The program prints a message to the console.

$ node first.js
This is our first application

Node.js read contents of file

Node.js contains the fs module to work with files.

blue
book
pen
dog
computer
screen

We have a text file.

Most functions in Node.js are asynchronous. The are non-blocking; i.e. they do not block the execution of the script.

const fs = require('fs')

fs.readFile('words.txt', 'utf-8', (err, data) => {
    if (err) throw err;
    console.log(data);
});

console.log("Script continues...")

The example reads the contents of the words.txt file.

const fs = require('fs');

We load the fs module.

fs.readFile('words.txt', 'utf-8', (err, data) => {

The readFile asynchronously reads the entire contents of a file. We specify the encoding in the second parameter of the method.

$ node read_file.js
Script continues
blue
book
pen
dog
computer
screen

The 'Script continues' is shown before the contents of the file.

Node.js read directory synchronously

Now we are going to read the contents of a directory.

const fs = require('fs');

readDirContentSync('.');

console.log("Ready.");

function readDirContentSync(mydir) {

    const filenames = fs.readdirSync(mydir);

    for (var i = 0; i < filenames.length; i++) {
        console.log(filenames[i]);
    }
}

The code example reads the contents of a directory synchronously.

const filenames = fs.readdirSync(mydir);

We read the directory synchronously with readdirSync.

for (var i = 0; i < filenames.length; i++) {
    console.log(filenames[i]);
}

We loop through the array of file names and print them to the console.

$ node readdir_syn.js
builtins.js
first.js
links
read_file.js
readdir_asyn.js
readdir_syn.js
server.js
todo
words.txt
Ready.

With a synchronous function call, the 'Ready.' message is shown after the function finishes its execution.

Node.js read directory asynchronously

In the next example, we read a directory asynchronously.

var fs = require('fs');

fs.readdir(".", (err, filenames) => {

    for (var i = 0; i < filenames.length; i++) {
        console.log(filenames[i]);
    }

    console.log("Ready.");
});

The readdir reads the contents of the current working directory asynchronously. It fills an array with the names of the files in the directory excluding '.' and '..'.

Node.js reading web page

In the following example we read a web page using a built-in http module.

const http = require('http');

const request = http.request({ hostname: 'webcode.me' }, (res) => {

    res.setEncoding('utf8');
    res.on('data', (chunk) => {

        console.log(chunk);
    });
});


request.end();

request.on('error', (err) => {

    console.log("Error occured\n");
    console.error(err);
});

In the example, we use the http module to create a request to a small web page. The returned HTML page is printed to the console.

$ node read_webpage.js
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My html page</title>
</head>
<body>

    <p>
        Today is a beautiful day. We go swimming and fishing.
    </p>

    <p>
         Hello there. How are you?
    </p>

</body>
</html>

We have received this small HTML page.

Node.js install module with npm

Additional modules can be installed with npm, the Node Package Manager. Now we are going to install a new module called builtin-modules. With this module we are going to list all available Node.js built-in modules.

$ mkdir builtmodtest
$ cd builtmodtest/
$ npm init

We create a new project directory. With npm init command we create a package.json file. It contains project-related metadata such as application name, author, or dependencies.

$ cat package.json
{
    "name": "builtmodtest",
    "version": "1.0.0",
    "description": "Testing builtin modules",
    "main": "main.js",
    "scripts": {
        "start": "node main.js"
    },
    "author": "Jan Bodnar",
    "license": "ISC"
}

This is the initial package.json file. We have chosen main.js to be the main file.

$ npm install builtin-modules
$ tree -L 1
.
├── main.js
├── node_modules
├── package.json
└── package-lock.json

With the npm install builtin-modules we install the builtin-modules module locally. A new node_modules directory is created where the modules and their dependencies are stored. A package-lock.json file was created automatically by npm. It is used to ensure consistent install of dependencies for teammates, deployments, and continuous integrations. This file must be committed to source repositories.

$ cat package.json
{
  "name": "builtmodtest",
  "version": "1.0.0",
  "description": "Testing builtin modules",
  "main": "main.js",
  "scripts": {
    "start": "node main.js"
  },
  "author": "Jan Bodnar",
  "license": "ISC",
  "dependencies": {
    "builtin-modules": "^2.0.0"
  }
}

The builtin-modules is also written to the package.json file.

const builtmods = require('builtin-modules');

console.log(builtmods);

This is the main.js file. It prints all the built-in modules to the console.

$ npm start

> [email protected] start /home/janbodnar/prog/nodejs/builtmod
> node main.js

[ 'assert',
  'async_hooks',
  'buffer',
  'child_process',
  'cluster',
  'config',
  'console',
  'constants',
...
]

Node.js server

We create a simple server with Node.js http module.

const http = require('http');

const server = http.createServer((req, res) => {

    res.writeHead(200, {"Content-Type": "text/plain"});
    res.end("Hello there\n");
});

server.listen(8000);

console.log("Server running at http://127.0.0.1:8000/");

The server sends a simple text message to the client.

const http = require('http');

We load the http module to create an http server.

const server = http.createServer((req, res) => {

    res.writeHead(200, {"Content-Type": "text/plain"});
    res.end("Hello there\n");
});

A server is created. It sends a text message to the client.

server.listen(8000);

The server listens on port 8000 on localhost.

$ node server.js &
$ curl localhost:8000
Hello there

We run the server and create a request with curl.

Source

Node.js documentation

In this article we have introduced Node.js. We have created some code examples with Node.js.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all JavaScript tutorials.