Node JS Tutorial for Beginners

Introduction

Confused about how browser JavaScript migrates to the backend, or maybe just confused by asynchronous programming and the Event Loop? Node.js allows you to create fast, scalable applications in the language you know.

This Node.js tutorial is focused on clarifying these common worries with practical examples. Take the first step toward becoming a full-stack developer! Ready to see what you will learn? Review our complete Node js Course Syllabus today and begin your journey!

Why Students or Freshers Learn Node JS?

Learning Node.js is a strategic move, considering that new developers/students enter the tech job market.

• Full-stack Power (One Language): The usage of JavaScript on both the frontend and backend sides allows for a full-stack development without the need to study a second language for the server side.
• High-Demand Jobs: Large companies like Netflix, PayPal, and LinkedIn use Node.js, so as a developer, the demand in the market for you will keep on increasing.
• Highly Performant, Fast Applications: Its non-blocking, event-driven architecture is ideal for constructing modern, high-performance real-time applications – chats, live updates.
• Rich Ecosystem (Npm): Having access to NPM and millions of packages accelerates development and simplifies project complexity.
• Diverse Career Paths: Opens up avenues to become a Full-Stack Developer, Backend Software Engineer, or a DevOps specialist.

Boost your preparation! Master your technical skills and get your first job. Check out today our essential list of Node js Interview Questions and Answers!

Step-by-Step Node.JS Tutorial for Beginners

Node.js is a high-performance, open-source, cross-platform runtime environment for executing JavaScript code outside of a web browser. It is built on Chrome’s V8 engine and is meant for fast and scalable server-side and networking applications. This Node.js tutorial will take you through installation to setting up your first server in easy steps.

Step 1: Installation and Verification

Setting up your development environment is the first step.

1.1. Node.js Download

Go to the official Node.js website and download its Long-Term Support version. Basically, LTS versions are recommended for most users since they guarantee more stability and support.

1.2. Run the Installer

• Windows/macOS: Double-click the installer package, then follow the installation prompts. The actual installer contains the Node.js runtime and npm (Node Package Manager).
• Linux: Installation via package manager, e.g., apt or yum, consult the official Node.js documentation for instructions specific to your distribution.

1.3. Installation Checks

Now, open your terminal/command prompt and execute the following commands. You should see the installed version numbers:

# Check Node.js version

node -v

# Check npm (Node Package Manager) version

npm -v

Step 2: Your First Node.js Program (A Console App)

Let’s start with a basic JavaScript file that executes directly on your computer.

2.1. Create a Project Folder

Create a new folder for your project and navigate into it using your terminal:

mkdir node-beginner-app

cd node-beginner-app

2.2. Write the Code

Open a file named app.js in your project folder and add the following code:

// app.js

const message = ‘Hello, Node.js Beginner!’;

console.log(message);

// Use a built-in Node.js module (OS module)

const os = require(‘os’);

console.log(`Your operating system is: ${os.platform()}`);

2.3. Execute the Program

Run the file using the node command:

node app.js

This shows that Node.js can run vanilla JavaScript and leverage native core modules like os here.

Output:

Hello, Node.js Beginner! Your operating system is: win32 // or ‘darwin’, ‘linux’, etc.

Step 3: Understanding npm and package.json

npm is the largest software registry in the world and the default package manager for Node.js. It can be used to easily install and manage external libraries called packages or modules for your project.

3.1. Initialize Your Project

The command given below needs to be executed within your project folder:

npm init

You will then be asked to input information: package name, version, and entry point-index.js or app.js is fine; you can just hit Enter to accept the defaults.

This command generates a file called package.json, which serves as a sort of manifest for your project. You will use it to keep track of project metadata, scripts, and-what’s most important-project dependencies.

// Example package.json

{

  “name”: “node-beginner-app”,

  “version”: “1.0.0”,

  “description”: “My first Node.js project”,

  “main”: “app.js”,

  “scripts”: {

    “test”: “echo \”Error: no test specified\” && exit 1″

  },

  “keywords”: [],

  “author”: “”,

  “license”: “ISC”

}

Step 4: Creating a Basic HTTP Web Server

Now, we will create a web request-handling server using the Node.js built-in module, http.

4.1. Create the Server File

Create a new file named server.js or app.js and paste the following:

// server.js

// 1. Import the built-in ‘http’ module

const http = require(‘http’);

const hostname = ‘127.0.0.1’; // The loopback address, or ‘localhost’

const port = 3000;

// 2. Create the server

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

  // This function runs every time a request is made to the server

  // Set the response HTTP header (Status: 200 OK, Content-Type: plain text)

  res.statusCode = 200;

  res.setHeader(‘Content-Type’, ‘text/plain’);

  // Send the response body

  res.end(‘Hello World from a Basic Node.js Server\n’);

});

// 3. Start the server and make it listen on the specified port and hostname

server.listen(port, hostname, () => {

  console.log(`Server running at http://${hostname}:${port}/`);

})

4.2. Run the Server

Save the file and execute it in your terminal:

node server.js

It will print out: Server running at http://127.0.0.1:3000/.

4.3. Test the Server

Open your web browser and go to http://localhost:3000/. You should see: “Hello World from a Basic Node.js Server“.

To halt the server, go back to your terminal and press Ctrl + C.

Step 5: Introducing Express.js (The Minimalist Framework)

In real-world applications, using the bare core http module can get complicated. Express.js is a fast, unopinionated, minimalist web framework that makes it easy to develop a server.

5.1. Install Express

First, stop your current server Ctrl+C and install Express using npm:

npm install express

This will download the Express package and add it automatically to the “dependencies” part in your package.json file. It will also create a node_modules folder where lives the code of the package.

5.2. Create an Express Server

Create a new file called express_server.js and use Express to get a more robust server:

// express_server.js

// 1. Import the Express module

const express = require(‘express’);

const app = express();

const port = 3000;

// 2. Define a basic route handler for the root URL (‘/’)

// app.get() handles HTTP GET requests

app.get(‘/’, (req, res) => {

  // Sending a string response. Express handles setting headers (like 200 OK and Content-Type) for you.

  res.send(‘Hello World from Express!’);

});

// 3. Define another route handler

app.get(‘/about’, (req, res) => {

  res.send(‘This is the About page for our Node/Express app.’);

});

// 4. Start the server

app.listen(port, () => {

  console.log(`Express app listening at http://localhost:${port}`);

});

5.3. Start the Express Server

Run the Express server file:

node express_server.js

Now go to your browser and access http://localhost:3000/ and http://localhost:3000/about to see the different responses.

Step 6: Understanding the Asynchronous Nature and the Event Loop

Node.js is designed on an event-driven, non-blocking I/O model, which is extremely important and a basic need to know even for beginners.

• Non-Blocking: Node.js doesn’t wait for I/O operations-like reading a file or querying a database-to finish. It immediately moves to the next instruction.
• Asynchronous: All I/O operations run in the background, and when these operations are finished, a callback function is pushed to the Event Loop to be executed, letting the main thread be free for handling other new requests.

This model is what makes Node.js highly efficient and scalable for I/O-intensive tasks, like web servers.

Example of Non-Blocking I/O (File System Module)

The built-in fs (File System) module has both synchronous and asynchronous methods. We prefer asynchronous to prevent blocking the Event Loop.

// async_example.js

const fs = require(‘fs’);

console.log(‘1. Start of the script.’);

// ASYNCHRONOUS (Non-Blocking) File Read

// Node.js starts reading the file, then immediately moves to the next line of code (console.log(‘2…’)).

fs.readFile(‘sample.txt’, ‘utf8’, (err, data) => {

  if (err) throw err;

  console.log(‘3. File read operation complete. Data:’, data);

});

console.log(‘2. End of the script. This runs BEFORE the file read completes.’);

If you make a file sample.txt that contains some data and then run node async_example.js then the order of outputs will be

1. Start of the script. 

2. End of the script. This runs BEFORE the file read completes. 

3. File read operation complete. Data: (content of sample.txt)

This corroborates the fact that it is non-blocking: the reading of the file was delegated, and the script finished its main execution thread before the file was ready.

Ready to put your new skills to the test? Solve real-world coding challenges that assess your ability in Express routing, database integration, and asynchronous handling. Challenge Yourself! Take a look at this list of Node js Challenges and Solutions, and improve your skills from beginner to proficient developer.

Real Time Examples for Node JS Tutorial for Learners

Node.js does very well in highly concurrent, low-latency applications. For more practical, real-time examples of Node.js’s core strengths, which are great learning projects for beginners, here is a list:

Live Chat Application Using WebSockets

Concept: This is the classical example to show Node.js’s event-driven architecture and scalability. You use the http module for the main server and libraries like Socket.IO to implement WebSockets.

How Node.js Helps: 

• WebSockets establish a persistent, two-way communication channel between the client and the server. 
• Node.js provides non-blocking I/O, allowing it to efficiently handle thousands of simultaneous connections, instantly broadcasting a message to all connected users with minimal resource overhead.

Learning Focus: Understanding WebSockets, event emitters and managing persistent connections.

Real-time Data Streaming and Notification Feed

Concept: Creating a system-so a simplified stock ticker, or a social media notification feed-would immediately push new data to the client the moment it occurs. 

How Node.js Helps: 

• Node.js can handle high-throughput data streams. 
• It uses the native stream module to process data in chunks, without the need to wait for a file/data set to load completely. 
• It is ideal for efficient server-to-client push mechanisms that ensure updates are shown to users instantly. 

Learning Focus: Work with Node.js streams, integrate with a database like MongoDB, handle asynchronous data flows.

Collaborative Text Editor or Whiteboard

Concept: Multiple users are able to edit the same document or draw on the same canvas, seeing changes done by others instantly, similar to Google Docs. 

How Node.js Helps: 

• Like the chat application, WebSockets enable the continuous exchange of these small data packets such as “User A inserted ‘t’ at position 5.”. 
• Node.js’s speed ensures that these operation transforms are applied and synchronized to all connected clients with a minimal delay for a seamless collaborative experience. 

Learning Focus: Server-side state management, handling parallel writes concurrency, and real-time state synchronization. 

Ready to build your portfolio? Start applying these concepts! Explore Node js project ideas and examples suitable for both beginners and intermediate learners. 

FAQs About Node JS Tutorial for Beginners

Conclusion

You have just walked through your first steps into Server-Side JavaScript. You now have a firm grasp of the key concepts: setup, the http module, Express.js, and the non-blocking Event Loop. This knowledge provides a foundation on which you can build fast, scalable, real-time applications. Node.js is not just a language; it’s a doorway to Full-Stack development. Structured learning is required to master other complex topics beyond the basics, such as database integration-for example, MongoDB-security, deployment, and so on. 

Ready to accelerate your career? Enroll in our comprehensive Node js Course in Chennai to build real-world projects and master interview concepts!