Loading lesson path
The Path module is a built-in Node.js module that provides tools for handling and transforming file paths across different operating systems. Since Windows uses backslashes ( \ ) and POSIX systems (Linux, macOS) use forward slashes ( /
Formula
), the Path module helps write cross - platform code that works correctly on any system.The Path module is a core module in Node.js, so no installation is needed. You can import it using either CommonJS or ES modules syntax: CommonJS (Node.js default)
const path = require('path');
// Destructure specific methods if needed const { join, resolve, basename } = require('path');Formula
ES Modules (Node.js 14 + with "type": "module" in package.json)import path from 'path';
// Or import specific methods import { join, resolve, basename } from 'path';Formula
For better tree - shaking and smaller bundle sizes, import only the methods you need when using ES modules.Path Module Methods path.basename() Returns the last portion of a path, similar to the Unix basename command.
const path = require('path');
// Get filename from a path const filename = path.basename('/users/docs/file.txt');
console.log(filename);
// Get filename without extension const filenameWithoutExt = path.basename('/users/docs/file.txt', '.txt');
console.log(filenameWithoutExt);dirname and filename In Node.js, dirname and filename are special variables available in CommonJS modules that provide the directory name and file name of the current module.
Example: Using dirname and filename in CommonJS // CommonJS module (e.g., app.js)
const path = require('path');
// Get the directory name of the current module console.log('Directory name:', __dirname);
// Get the file name of the current module console.log('File name:', __filename);
// Building paths relative to the current module const configPath = path.join(__dirname, 'config', 'app-config.json');
console.log('Config file path:', configPath);
// Getting the directory name using path.dirname()
console.log('Directory using path.dirname():', path.dirname(__filename));Example: Getting dirname and filename in ES Modules // ES Module (e.g., app.mjs or "type": "module" in package.json)
import { fileURLToPath } from 'url';
import { dirname } from 'path';
// Get the current module's URL
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
console.log('ES Module file path:', __filename);
console.log('ES Module directory:', __dirname);
// Example with dynamic imports async function loadConfig() {
const configPath = new URL('../config/app-config.json', import.meta.url);
const config = await import(configPath, { with: { type: 'json' } });
return config;
}Use path.join() or path.resolve() with __dirname to build file paths in CommonJS modules. For ES modules, use import.meta.url with fileURLToPath and dirname to get the equivalent functionality.
__dirname with path.join(), you can safely use forward slashes as they'll be normalized to the correct platform separator. path.extname() Returns the extension of a path, from the last occurrence of the. character to the end of the string.
const path = require('path');
const extension = path.extname('file.txt');
console.log(extension);
console.log(path.extname('index.html'));
console.log(path.extname('index.coffee.md'));
console.log(path.extname('index.'));
console.log(path.extname('index'));
console.log(path.extname('.index'));
path.join()Joins all given path segments together using the platform-specific separator as a delimiter, then normalizes the resulting path.
Example: Basic path joining const path = require('path');
// Join path segments const fullPath = path.join('/users', 'docs', 'file.txt');
console.log(fullPath); // Output depends on OS
// Handle relative paths and navigation console.log(path.join('/users', '../system', './logs', 'file.txt'));
// Handle multiple slashes console.log(path.join('users', '//docs', 'file.txt')); // Normalizes slashespath.join() is preferred over string concatenation with + as it handles different path separators across operating systems. path.resolve() Resolves a sequence of paths or path segments into an absolute path, processing from right to left until an absolute path is constructed.
Example: Resolving paths const path = require('path');
// 1. Resolve relative to current working directory console.log(path.resolve('file.txt'));
// 2. Resolve with multiple segments console.log(path.resolve('/users', 'docs', 'file.txt'));
// 3. Right-to-left processing console.log(path.resolve('/first', '/second', 'third')); // '/second/third'
// 4. Using __dirname for module-relative paths console.log(path.resolve(__dirname, 'config', 'app.json'));path.resolve() is commonly used with __dirname to create absolute paths relative to the current module's location. path.parse() Returns an object whose properties represent significant elements of the path.
Example: Parsing a file path const path = require('path');
// Parse a file path const pathInfo = path.parse('/users/docs/file.txt');
console.log(pathInfo);Formula
/* Output on Unix/macOS:{Formula
root: '/', dir: '/users/docs', base: 'file.txt', ext: '.txt', name: 'file'}*/ // Accessing parsed components console.log('Directory:', pathInfo.dir); // /users/docs console.log('Filename:', pathInfo.base); // file.txt console.log('Name only:', pathInfo.name); // file console.log('Extension:', pathInfo.ext); // .txt
The output of path.parse() can be passed to path.format() to reconstruct the path. path.format() Returns a path string from an object, which is the opposite of path.parse().
Example: Formatting path objects const path = require('path');
Formula
// Method 1: Using dir and base const pathString1 = path.format({
dir: '/users/docs', base: 'file.txt'});
console.log(pathString1); // '/users/docs/file.txt'Formula
// Method 2: Using root, dir, name, and ext const pathString2 = path.format({
root: '/', dir: '/users/docs', name: 'file', ext: '.txt'});
console.log(pathString2); // '/users/docs/file.txt'Formula
// Practical example: Modify and reconstruct a path const parsedPath = path.parse('/users/docs/old - file.txt');parsedPath.base = 'new-file.md';
const newPath = path.format(parsedPath);
console.log(newPath); // '/users/docs/new-file.md'When using path.format(), if the dir and root properties are provided, root is ignored. path.normalize() Normalizes the given path, resolving.. and. segments and removing redundant separators.
Example: Normalizing paths const path = require('path');
// Resolve relative navigation console.log(path.normalize('/users/./docs/../data/file.txt')); // '/users/data/file.txt'
// Handle multiple consecutive slashes console.log(path.normalize('/users//docs////file.txt')); // '/users/docs/file.txt'Formula
// Windows - style paths (automatically handled)console.log(path.normalize('C:\\users\\docs\\..\\file.txt')); // 'C:\\users\\file.txt'
// Edge cases console.log(path.normalize('')); // '.'
console.log(path.normalize('.')); // '.'
console.log(path.normalize('..')); // '..'
console.log(path.normalize('/..')); // '/'While path.normalize() resolves.. sequences, it doesn't protect against directory traversal attacks. Always validate and sanitize user input when working with file paths. path.relative() Returns the relative path from the first path to the second path, or an empty string if the paths are the same.
Example: Finding relative paths const path = require('path');
// Basic relative path console.log(path.relative('/users/docs/file.txt', '/users/images/photo.jpg'));Formula
// Output: '../../images/photo.jpg'// Same directory console.log(path.relative('/users/docs/file1.txt', '/users/docs/file2.txt'));
// Output: 'file2.txt'
// Same file console.log(path.relative('/users/docs/file.txt', '/users/docs/file.txt'));
// Output: ''
// Different roots (Windows)
console.log(path.relative('C:\\user\\test\\aaa', 'C:\\user\\impl\\bbb'));
// Output: '..\\..\\impl\\bbb'Formula
// Practical example: Creating a relative path for web const absolutePath = '/var/www/static/images/logo.png';const webRoot = '/var/www/';
const webPath = path.relative(webRoot, absolutePath).replace(/\\/g, '/');
console.log(webPath); // 'static/images/logo.png'path.relative() is particularly useful when you need to generate relative URLs or create portable paths between different locations in your project. path.isAbsolute() Determines if the given path is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory.
Example: Checking for absolute paths const path = require('path');
Formula
// POSIX (Unix/Linux/macOS)console.log(path.isAbsolute('/users/docs')); // true console.log(path.isAbsolute('users/docs')); // false
// Windows console.log(path.isAbsolute('C:\\temp')); // true console.log(path.isAbsolute('temp')); // false
// UNC paths (Windows network paths)
console.log(path.isAbsolute('\\\\server\\share')); // true
// Practical example: Ensure absolute path for config files function ensureAbsolute(configPath) {
return path.isAbsolute(configPath)? configPath
: path.resolve(process.cwd(), configPath);
}
console.log(ensureAbsolute('config.json')); // Resolves to absolute path console.log(ensureAbsolute('/etc/app/config.json')); // Already absoluteOn Windows, paths starting with a drive letter followed by a colon (e.g., 'C:\\') are considered absolute, as are UNC paths (e.g., '\\\\server\\share'). Path Properties path.sep
Formula
Provides the platform - specific path segment separator.
This is a read - only property that returns the default path segment separator for the current operating system.Example: Working with path separators const path = require('path'); // Get the platform-specific separator console.log(Path separator: ${JSON.stringify(path.sep)}); // '\\' on Windows, '/' on POSIX
// Building paths safely across platforms const parts = ['users', 'docs', 'file.txt'];
const filePath = parts.join(path.sep);
console.log('Built path:', filePath);
// Splitting paths correctly const pathToSplit = process.platform === 'win32'
? 'C:\\Users\\docs\\file.txt'
: '/users/docs/file.txt';
const pathParts = pathToSplit.split(path.sep);
console.log('Split path:', pathParts);
// Normalizing paths with the correct separator const normalized = path.normalize(`users${path.sep}docs${path.sep}..${path.sep}file.txt`);
console.log('Normalized path:', normalized);Always use path.sep instead of hardcoding path separators to ensure cross-platform compatibility in your Node.js applications. path.delimiter
Formula
Provides the platform - specific path delimiter used to separate paths in environment variables likePATH.
Example: Working with PATH environment variable const path = require('path'); // Get the platform-specific delimiter console.log(Path delimiter: ${JSON.stringify(path.delimiter)}); // ';' on Windows, ':' on POSIX
// Working with PATH environment variable function findInPath(executable) {
if (!process.env.PATH) return null;
// Split PATH into directories const pathDirs = process.env.PATH.split(path.delimiter);
// Check each directory for the executable for (const dir of pathDirs) {
try {
const fullPath = path.join(dir, executable);
require('fs').accessSync(fullPath, require('fs').constants.X_OK);
return fullPath;
} catch (err) {
// File not found or not executable continue;
}
}
return null;
}// Example: Find node executable in PATH
const nodePath = findInPath(process.platform === 'win32' ? 'node.exe' : 'node');
console.log('Node.js path:', nodePath || 'Not found in PATH');The path.delimiter is primarily used for working with environment variables like
or NODE_PATH that contain multiple paths. path.win32 Provides access to Windows-specific path methods, allowing you to work with Windows-style paths regardless of the operating system you're running on.
Example: Working with Windows paths on any platform const path = require('path');
Formula
// Always use Windows - style path handling const winPath = 'C:\\Users\\user\\Documents\\file.txt';console.log('Windows basename:', path.win32.basename(winPath));
console.log('Windows dirname:', path.win32.dirname(winPath));
// Normalize Windows paths console.log('Normalized path:', path.win32.normalize('C:\\\\temp\\\\foo\\..\\bar\\file.txt'));Formula
// Convert between forward and backward slashes const mixedPath = 'C:/Users/User/Documents//file.txt';console.log('Normalized mixed slashes:', path.win32.normalize(mixedPath));
// Working with UNC paths const uncPath = '\\\\server\\share\\folder\\file.txt';
console.log('UNC path components:', path.win32.parse(uncPath));The path.win32 object is particularly useful when your application needs to work with Windows-style paths on non-Windows platforms, such as when processing paths from a Windows system log or configuration file. path.posix
Formula
Provides access to POSIX - compliant path methods, ensuring consistent forward - slash path handling across all platforms.Example: Working with POSIX paths on any platform const path = require('path');
// Always use POSIX-style path handling const posixPath = '/home/user/documents/file.txt';
console.log('POSIX basename:', path.posix.basename(posixPath));
console.log('POSIX dirname:', path.posix.dirname(posixPath));Formula
// Normalize POSIX paths console.log('Normalized path:', path.posix.normalize('/usr/local//bin/../lib/file.txt'));
// Working with relative paths console.log('Relative path:', path.posix.relative('/data/test/aaa', '/data/impl/bbb'));// Joining paths with POSIX separators const urlPath = ['static', 'images', 'logo.png'].join(path.posix.sep);
console.log('URL path:', urlPath); // 'static/images/logo.png'The path.posix object is particularly useful when you need to ensure consistent path handling for web applications, configuration files, or when working with APIs that expect POSIX-style paths, regardless of the underlying operating system.