Node.js Basics — Variables, Functions, Callbacks

Node.js Basics

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.

This page focuses on the most important fundamentals that beginners need in order to read and write Node.js programs confidently. Even though many of the syntax rules come from JavaScript, the examples here are chosen with Node.js usage in mind so that the concepts connect naturally to real server-side code.

Core Concepts You Should Know First

• Variables and constants for storing values.
• Primitive and reference data types.
• Operators for calculations, comparison, and logic.
• Functions for organizing reusable code.
• Arrays and objects for grouping data.
• Node.js globals like console, process, and global.

Data Types in Node.js

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.

Primitive Data Types

• String - text values like names, messages, file paths, or URLs.
• Number - integers and decimal values.
• Boolean - true or false.
• Null - an intentional empty value.
• Undefined - a variable that has been declared but not assigned a value.
• BigInt - very large integers.
• Symbol - unique identifiers, used less often in beginner code.

Reference Data Types

• Object - key-value pairs used heavily in Node.js for configuration, JSON data, and request handling.
• Array - ordered lists of values.
• Date - date and time objects.
• Function - reusable blocks of behavior.

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);      // object

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.

Variables: var, let, and const

Variables 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.

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);

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.

const config = {
    host: "localhost",
    port: 3000
};

config.port = 4000; // allowed
console.log(config.port); // 4000

Operators in Node.js

Operators 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.

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);

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.

Functions in Node.js

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.

function sayHello(name) {
    return `Hello, ${name}!`;
}

console.log(sayHello("Ravi"));

Modern Node.js code also uses arrow functions very often, especially with arrays, callbacks, promises, and asynchronous APIs.

const multiply = (x, y) => x * y;

console.log(multiply(4, 5)); // 20

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.

Arrays and Objects

Arrays 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.

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' ]

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.

Conditions and Control Flow

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.

const age = 20;

if (age >= 18) {
    console.log("Adult user");
} else {
    console.log("Minor user");
}

Control flow also includes loops such as for, while, and for...of. These are useful when processing collections of records, files, or request data.

Node.js Globals You Should Recognize

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.

• console - used for logging output and debugging.
• process - gives access to environment variables, arguments, and runtime information.
• global - the global object in Node.js.
• setTimeout() and setInterval() - timer functions.
• __dirname and __filename - useful in CommonJS modules for current path information.

console.log(process.version);
console.log(process.cwd());
console.log(__dirname);
console.log(__filename);

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.

Synchronous vs Asynchronous Thinking

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.

console.log("Start");

setTimeout(() => {
    console.log("This runs later");
}, 1000);

console.log("End");

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.

A Simple Node.js Basics Example

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.");
}

Common Beginner Mistakes

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.