Node.js Path Module

The path module is a built-in Node.js module that provides utilities for working with file and directory paths. File paths can look very different on different operating systems — for example, Windows uses backslashes (\) while macOS and Linux use forward slashes (/). The path module handles these differences automatically, making code work correctly across all platforms.

Think of the path module as a reliable assistant that knows how to properly put together, take apart, and navigate file paths — no matter what operating system is being used.

Loading the Path Module

const path = require('path');

Common Path Module Methods

path.join() – Joining Path Segments

path.join() combines multiple path segments into a single path, using the correct separator for the current operating system.

const path = require('path');

const fullPath = path.join('users', 'alice', 'documents', 'report.txt');
console.log(fullPath);

Output on macOS/Linux:

users/alice/documents/report.txt

Output on Windows:

users\alice\documents\report.txt

Using path.join() ensures the right slash is always used, regardless of the platform.

path.resolve() – Getting an Absolute Path

path.resolve() creates an absolute path — a path that starts from the root of the file system. It resolves path segments from right to left and stops when it builds a full absolute path.

const path = require('path');

const absolutePath = path.resolve('reports', 'monthly.pdf');
console.log(absolutePath);

Output (example on Linux):

/home/user/project/reports/monthly.pdf

This is especially useful when a full path is needed to pass to another function like fs.readFile().

path.basename() – Getting the File Name

path.basename() returns the last part of a path — usually the file name.

const path = require('path');

const filePath = '/home/user/documents/notes.txt';

console.log(path.basename(filePath));          // notes.txt
console.log(path.basename(filePath, '.txt'));  // notes (extension removed)

The optional second argument removes the specified extension from the result.

path.dirname() – Getting the Directory Name

path.dirname() returns the folder/directory part of a path — everything except the last segment.

const path = require('path');

const filePath = '/home/user/documents/notes.txt';

console.log(path.dirname(filePath));
// Output: /home/user/documents

path.extname() – Getting the File Extension

path.extname() returns the extension of the file (including the dot).

const path = require('path');

console.log(path.extname('image.png'));   // .png
console.log(path.extname('app.js'));      // .js
console.log(path.extname('README.md'));   // .md
console.log(path.extname('archive'));     // (empty string)

path.parse() – Breaking a Path into Parts

path.parse() breaks a complete path into an object with separate parts: root, directory, base, extension, and name.

const path = require('path');

const parsed = path.parse('/home/user/projects/app.js');
console.log(parsed);

Output:

{
  root: '/',
  dir: '/home/user/projects',
  base: 'app.js',
  ext: '.js',
  name: 'app'
}

path.format() – Building a Path from Parts

path.format() does the opposite of path.parse() — it takes an object of path parts and assembles them into a complete path string.

const path = require('path');

const pathObject = {
  dir: '/home/user/projects',
  name: 'app',
  ext: '.js'
};

console.log(path.format(pathObject));
// Output: /home/user/projects/app.js

Important Path Properties

path.sep – Path Separator

path.sep holds the operating system-specific path segment separator:

const path = require('path');

console.log(path.sep);
// Output on Linux/macOS: /
// Output on Windows: \

path.delimiter – Environment Variable Delimiter

path.delimiter holds the character used to separate paths in the system's PATH environment variable:

const path = require('path');

console.log(path.delimiter);
// Output on Linux/macOS: :
// Output on Windows: ;

Using __dirname and __filename

Two special global variables are available in every Node.js file:

• __dirname — the absolute path of the current directory where the file is located.
• __filename — the absolute path of the current file itself.

These are extremely useful when constructing paths relative to the current file:

// app.js
const path = require('path');

console.log(__dirname);
// Example output: /home/user/project

console.log(__filename);
// Example output: /home/user/project/app.js

// Building a path to a data file in the same directory
const dataFilePath = path.join(__dirname, 'data', 'users.json');
console.log(dataFilePath);
// Output: /home/user/project/data/users.json

Using __dirname with path.join() is a best practice for building reliable file paths that work on any machine and operating system.

Practical Example – Building a Path to a Static File

const path = require('path');
const fs = require('fs');

// Build the full path to a configuration file
const configPath = path.join(__dirname, 'config', 'settings.json');

// Read the file
fs.readFile(configPath, 'utf8', function(err, data) {
  if (err) {
    console.log("Config file not found:", err.message);
    return;
  }
  console.log("Config loaded:", data);
});

This pattern — using path.join(__dirname, ...) to locate files relative to the current file — is used extensively in real Node.js applications.

Key Points

• The path module handles file path operations across different operating systems.
• path.join() combines path segments using the correct OS separator.
• path.resolve() returns an absolute path from the file system root.
• path.basename() returns the file name; path.dirname() returns the folder name.
• path.extname() extracts the file extension from a path.
• path.parse() splits a path into components; path.format() assembles them back.
• __dirname and __filename are global variables representing the current directory and file path respectively.
• Using path.join(__dirname, ...) is a best practice for constructing reliable cross-platform file paths.