JavaScript Prerequisites for Node.js

Before writing Node.js programs, you need to be comfortable with modern JavaScript (ES6+) syntax, since almost all Node.js code — and every example in this course — is written using it. Modern JavaScript prefers const and let over the older var keyword.

• const — declares a variable that cannot be reassigned. Use this by default.
• let — declares a variable that can be reassigned later. Use this only when the value needs to change.
• var — the old, function-scoped way of declaring variables. Avoid it in new Node.js code.

JavaScript's core data types are: string, number, boolean, null, undefined, object, and symbol. Template literals (backtick strings) let you embed expressions directly inside text using ${'{'}...{'}'}.

const courseName = "Node.js Master Course";
let studentsEnrolled = 120;

studentsEnrolled = studentsEnrolled + 1;

console.log(`${courseName} now has ${studentsEnrolled} students.`);

Functions are the core building block of any Node.js application — every route handler, callback, and middleware is a function. Modern JavaScript offers a concise arrow function syntax alongside the traditional function keyword.

Arrow functions do not bind their own this — they inherit it from the surrounding scope, which is why they're preferred inside callbacks and class methods where losing the outer this is a common bug.

// Traditional function declaration
function add(a, b) {
  return a + b;
}

// Arrow function with a default parameter
const greet = (name = "Developer") => {
  return `Hello, ${name}! Welcome to Node.js.`;
};

console.log(add(5, 7));
console.log(greet());
console.log(greet("Balaji"));

Node.js APIs constantly hand you back arrays and objects — HTTP headers, query parameters, database rows, JSON responses. Being fluent with array/object syntax and destructuring is essential.

• Destructuring extracts values from arrays or objects into individual variables in one line.
• Spread (...) expands an array or object's contents — useful for copying, merging, and passing multiple arguments.

const course = {
  title: "Node.js Master Course",
  level: "Beginner to Advanced",
  chapters: 49,
};

// Object destructuring
const { title, chapters } = course;
console.log(title, "-", chapters, "chapters");

// Spread to create a new object with an extra field
const updatedCourse = { ...course, edition: 2026 };
console.log(updatedCourse);

// Array destructuring
const [first, second] = ["Node.js", "Express.js"];
console.log(first, second);

Because Node.js is asynchronous by nature, you'll write asynchronous JavaScript constantly. There are three patterns for handling async code, and Node.js code today typically uses all three depending on the API:

• Callbacks: a function passed as an argument, invoked later once an operation finishes.
• Promises: objects representing a value that will be available eventually — either resolved (success) or rejected (failure).
• async/await: syntax sugar built on top of Promises that lets asynchronous code read like synchronous code.

// 1. Promise-based helper that "simulates" an async task
function delay(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

// 2. async/await — the modern, preferred style
async function loadCourse() {
  console.log("Loading course data...");
  await delay(1000);
  console.log("Course data loaded!");
}

loadCourse();

Two more building blocks you'll use constantly in Node.js: modules (splitting code across files) and JSON (the data format almost every API speaks).

JavaScript's built-in JSON.stringify() converts a JavaScript object into a JSON string (for sending over the network or writing to a file), and JSON.parse() converts a JSON string back into a usable JavaScript object.

You'll also frequently deal with basic HTTP concepts — requests, responses, status codes (like 200 OK, 404 Not Found), and headers — since Node.js is most often used to build HTTP servers and API clients (covered fully in Phase 6).

const course = { title: "Node.js Master Course", chapters: 49 };

// Convert JS object -> JSON string (e.g. to send over the network)
const jsonString = JSON.stringify(course);
console.log(typeof jsonString, jsonString);

// Convert JSON string -> JS object (e.g. after receiving an API response)
const parsedBack = JSON.parse(jsonString);
console.log(typeof parsedBack, parsedBack.title);