Node.js uses JavaScript as its programming language, so the basic building blocks of Node.js code are the same building blocks you see in JavaScript itself: variables, data types, operators, functions, arrays, objects, conditions, and loops. The difference is the runtime environment. In the browser, JavaScript mostly works with the DOM and user interface. In Node.js, JavaScript is used to work with files, servers, APIs, environment variables, and system-level tasks. That means learning the basics in a Node.js context is essential before moving on to modules, HTTP servers, file handling, or databases.
Node.js does not define a separate language or a separate set of language keywords. Words such as const, let, function, class, if, await, import, and export come from JavaScript. Names such as process, Buffer, setImmediate, and console are runtime globals or APIs, while node:fs and node:http are built-in modules. Keeping those categories separate makes documentation and errors easier to understand.
Because Node.js runs JavaScript, it supports the standard JavaScript data types. These are commonly grouped into primitive and reference types. Primitive values store simple individual values, while reference types store more complex structures such as collections and objects.
In Node.js applications, arrays and objects appear constantly. API responses are often arrays of objects, configuration values are often stored in objects, and incoming JSON request bodies are usually parsed into objects. Because of that, mastering arrays and objects is especially important for server-side development.
const appName = "Tutorials Logic";
const port = 3000;
const isRunning = true;
const data = null;
let result;
const scores = [78, 85, 92];
const user = { name: "Amit", role: "admin" };
console.log(typeof appName); // string
console.log(typeof port); // number
console.log(typeof isRunning); // boolean
console.log(typeof result); // undefined
console.log(Array.isArray(scores)); // true
console.log(typeof user); // objectVariables store data values in memory. JavaScript offers three main keywords for declaring variables: var, let, and const. In modern Node.js development, let and const are preferred, while var is mostly avoided because of its function scope and other older behaviors that can create confusion.
Use const when the variable reference should not be reassigned. Use let when the value will change over time. A common beginner mistake is assuming that const makes an object completely immutable. It does not. It only prevents the variable from pointing to a new object. The contents of the object can still change unless you intentionally freeze them.
var oldStyle = "Avoid in modern code";
let counter = 1;
const appTitle = "Node Basics";
counter = counter + 1; // allowed
// appTitle = "Changed"; // Error: Assignment to constant variable
console.log(counter);
console.log(appTitle);const config = {
host: "localhost",
port: 3000
};
config.port = 4000; // allowed
console.log(config.port); // 4000Operators are symbols used to perform calculations, comparisons, assignments, and logical checks. They are heavily used in Node.js for validation, branching, arithmetic, filtering, and condition-based decision making.
In real Node.js code, operators are often used to validate request input, compare authentication roles, calculate totals, or decide whether a file, user, or record meets a condition. The ternary operator is especially useful for short formatting decisions, but if a condition becomes complex, a normal if statement is easier to read.
| Operator Type | Examples | Purpose |
|---|---|---|
| Arithmetic | + - * / % ++ -- | Math calculations |
| Assignment | = += -= *= /= %= | Assign and update values |
| Comparison | == === != !== > < >= <= | Compare two values |
| Logical | && || ! | Combine or invert conditions |
| Ternary | condition ? value1 : value2 | Short conditional expression |
| Bitwise | & | ^ ~ << >> >>> | Bit-level operations |
const a = 10;
const b = 3;
console.log(a + b); // 13
console.log(a % b); // 1
console.log(a > b); // true
console.log(a === 10); // true
console.log(a > 5 && b < 5); // true
const status = a > b ? "greater" : "smaller";
console.log(status);A function is a reusable block of code designed to perform a particular task. Functions are one of the most important basics in Node.js because almost every real application uses them to organize routing, data processing, validation, database interaction, and utility logic.
Modern Node.js code also uses arrow functions very often, especially with arrays, callbacks, promises, and asynchronous APIs.
A strong habit is to keep functions focused. For example, one function can validate input, another can format data, and another can save it. This makes your code easier to test and reuse.
function sayHello(name) {
return `Hello, ${name}!`;
}
console.log(sayHello("Ravi"));const multiply = (x, y) => x * y;
console.log(multiply(4, 5)); // 20Arrays and objects are everywhere in Node.js. A list of users returned from a database is often an array of objects. A configuration file is usually an object. A JSON API response may contain nested arrays and objects together.
Methods like map(), filter(), and find() are extremely useful in Node.js because they help transform and search data cleanly. If you work with API responses, file records, or database results, these methods appear often.
const users = [
{ id: 1, name: "Anita", role: "admin" },
{ id: 2, name: "Karan", role: "editor" }
];
const activeUser = users[0];
console.log(activeUser.name); // Anita
console.log(users.length); // 2
const names = users.map(user => user.name);
console.log(names); // [ 'Anita', 'Karan' ]Node.js programs frequently need to make decisions. A request might be allowed only if the user is logged in. A file might be processed only if it exists. A function might return an error if input is missing. These situations depend on conditionals like if, else, and switch.
Control flow also includes loops such as for, while, and for...of. These are useful when processing collections of records, files, or request data.
const age = 20;
if (age >= 18) {
console.log("Adult user");
} else {
console.log("Minor user");
}Node.js provides several global objects and utilities that are available without importing them. These are part of the Node.js runtime and are different from browser-only globals like window and document.
These globals become very useful when writing file system code, reading environment variables, or debugging project setup issues. For example, process.env.PORT is commonly used to read a server port from the environment instead of hardcoding it into source code.
console.log(process.version);
console.log(process.cwd());
console.log(__dirname);
console.log(__filename);One of the first truly Node-specific basics is understanding that many operations do not finish immediately. File reads, database queries, and HTTP requests usually take time, so Node.js commonly handles them asynchronously. That means your code starts an operation and continues running while it waits for the result.
The output order is Start, then End, and only after the delay does This runs later appear. This simple example introduces the mindset required for callbacks, promises, and async/await, which are all essential in Node.js development.
console.log("Start");
setTimeout(() => {
console.log("This runs later");
}, 1000);
console.log("End");The following example combines several basics together: variables, arrays, objects, functions, conditions, and logging. This is closer to the kind of code you may actually write in an entry-level Node.js program.
const app = {
name: "Demo API",
port: 3000,
users: [
{ id: 1, name: "Anu", active: true },
{ id: 2, name: "Rohit", active: false }
]
};
function getActiveUsers(users) {
return users.filter(user => user.active);
}
const activeUsers = getActiveUsers(app.users);
if (activeUsers.length > 0) {
console.log(`${app.name} has ${activeUsers.length} active users.`);
console.log(activeUsers);
} else {
console.log("No active users found.");
}One common mistake is using var everywhere instead of choosing const and let intentionally. Another is confusing == and ===; in modern code, === is usually safer because it checks both value and type. Beginners also often assume asynchronous code runs in the same top-to-bottom order as synchronous code, which leads to confusing bugs. Finally, many developers coming from browser JavaScript forget that Node.js does not provide the DOM, so objects like window and document are not available by default.
The best way to build confidence is to practice with small scripts. Print values with console.log(), test arrays and objects, experiment with functions, and observe how asynchronous examples behave. Those habits build the foundation needed for later topics like modules, HTTP servers, file handling, and database work.
When reading Node code, separate call-stack work, promise reactions, `process.nextTick` callbacks, timers, I/O callbacks, and immediates. Ordering claims should be tested on the supported runtime and should not depend on timing races. Repeated microtasks or next-tick callbacks can starve I/O even though each callback appears small.
Measure blocking with realistic payloads and concurrency. Replace synchronous request-path work, partition long computations, or move sustained CPU work to a bounded worker pool. Workers protect event-loop responsiveness but still consume memory and CPU, so queue length, cancellation, timeout, and overload behavior remain application responsibilities.
const prevents rebinding the variable name; it does not freeze the object stored in that variable. You cannot assign a new object to the same const, but you can still change properties unless the object is frozen or treated immutably by convention.
Many Node APIs start work and return immediately, then call your callback later when the result is ready. The surrounding function does not wait unless you return a Promise and await it, or you put the dependent logic inside the callback chain.
Browser JavaScript has window, document, and DOM APIs. Node has process, Buffer, __dirname in CommonJS, file system access, environment variables, and server-side modules.
Explore 500+ free tutorials across 20+ languages and frameworks.