Introduction to Node.js

JavaScript Beyond the Browser

For a long time, JavaScript lived exclusively inside web browsers. Its job was to make websites interactive, handling things like button clicks and animations. If you wanted to build the part of an application that runs on a server—managing databases, handling user accounts, or processing data—you had to use a different language, like Python, Java, or PHP.

Node.js changed that. It’s a runtime environment that allows you to run JavaScript code directly on a computer or server, outside of a browser. Think of it as a special program that understands and executes JavaScript, giving it new powers like accessing the file system and handling network requests.

Node.js – JavaScript everywhere – is an open-source, cross-platform, JavaScript runtime environment that provides way to run JavaScript code outside of a web browser.

At its heart, Node.js uses the V8 JavaScript engine, the same high-performance engine that powers the Google Chrome browser. This means Node.js is not only versatile but also incredibly fast.

The Non-Blocking Advantage

The real magic of Node.js lies in its non-blocking, event-driven architecture. This sounds complex, but a simple analogy makes it clear.

Imagine a traditional server as a chef cooking one dish at a time. The chef takes an order, prepares it completely, serves it, and only then starts on the next order. If an order involves baking something for 30 minutes, the chef just waits by the oven. Nothing else gets done. This is a blocking model.

Node.js works like a much more efficient chef. This chef takes an order, puts the dish in the oven, and then immediately moves on to chopping vegetables for the next order. When the oven timer dings (an "event"), the chef returns to the first dish to take it out. This chef can handle many orders at once without getting stuck waiting. This is the non-blocking model, and it makes Node.js exceptionally good at handling many simultaneous connections, like in a chat application or a busy API.

Setting Up Your Environment

Getting started with Node.js is straightforward. You just need to install it on your machine. The official Node.js website provides installers for Windows, macOS, and Linux.

Go to nodejs.org.
Download the installer for the LTS (Long Term Support) version. LTS versions are recommended for most users because they are stable and will be supported with bug fixes and security updates for an extended period.
Run the installer and follow the on-screen instructions, accepting the default settings.

When you install Node.js, you also get npm (Node Package Manager). npm is a massive library of open-source packages and a command-line tool for installing them, which you'll use extensively as you build more complex applications.

To check that everything installed correctly, open your terminal or command prompt and run these two commands:

# Check Node.js version
node -v

# Check npm version
npm -v

If the installation was successful, each command will print its version number. Now you're ready to write your first Node.js script.

Your First Node.js Script

Let's create a classic "Hello, World!" program.

Create a new file named app.js. You can use any text editor, like VS Code, Sublime Text, or even Notepad.
Add the following line of code to the file:

// app.js
console.log("Hello from Node.js!");

This might look familiar. It's the same JavaScript console.log() function used in browsers. Now, let's run it.

Open your terminal, navigate to the directory where you saved app.js, and type the following command:

node app.js

Press Enter. You should see the message Hello from Node.js! printed directly in your terminal. You've just executed a JavaScript file on your computer—no browser needed.

This is the core of Node.js development: write JavaScript in a file, and use the node command to run it.

Let's try something that you can't do in a browser: interacting with the file system. Node.js has a built-in module called fs (short for file system) for this purpose. First, let's create a file to read. Make a new file called message.txt in the same directory and write a short sentence in it, like "Node.js can read this file."

Now, update your app.js file with the following code:

const fs = require('fs');

fs.readFile('message.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading the file:', err);
    return;
  }
  console.log('File content:', data);
});

console.log('Reading file...');

Let's break this down:

const fs = require('fs'); imports the built-in file system module.
fs.readFile() is the function to read a file. It's asynchronous. It takes the file path, encoding type, and a callback function as arguments.
The callback function (err, data) => { ... } runs after the file has been read. It receives an error object (err) if something went wrong, or the file's contents (data) if it was successful.

Run node app.js again. You'll see this output:

Reading file...
File content: Node.js can read this file.

Notice that "Reading file..." printed first, even though it's the last line of code. This is the non-blocking model in action. Node.js started the file reading operation and immediately moved to the next line (console.log('Reading file...')). When the file was finished being read, the callback function was executed, printing the file's content. This simple example showcases the powerful, asynchronous nature of Node.js.

Quiz Questions 1/6

What is the primary purpose of Node.js?

Quiz Questions 2/6

The non-blocking architecture of Node.js is like an efficient chef who...

Node.js Express Mongoose Backend Development