Node.js Built-ins Cheatsheet

node

Core Node.js modules reference — fs, path, http, crypto, events.

6 sections · 50 items

fs/promises - File System

readFile

fs.readFile(path[, options]): Promise<Buffer | string>

Asynchronously reads the entire contents of a file

typescript

const data = await fs.readFile('./file.txt', 'utf8');

writeFile

fs.writeFile(path, data[, options]): Promise<void>

Asynchronously writes data to a file, replacing the file if it exists

typescript

await fs.writeFile('./output.txt', 'Hello World', 'utf8');

appendFile

fs.appendFile(path, data[, options]): Promise<void>

Asynchronously appends data to a file, creating the file if it does not exist

typescript

await fs.appendFile('./log.txt', 'New log entry\n');

readdir

fs.readdir(path[, options]): Promise<string[] | Dirent[]>

Reads the contents of a directory and returns an array of filenames

typescript

const files = await fs.readdir('./src', { withFileTypes: true });

mkdir

fs.mkdir(path[, options]): Promise<string | undefined>

Asynchronously creates a directory

typescript

await fs.mkdir('./nested/dir', { recursive: true });

fs.rm(path[, options]): Promise<void>

Removes files and directories, similar to rm -rf

typescript

await fs.rm('./temp', { recursive: true, force: true });

stat

fs.stat(path[, options]): Promise<Stats>

Returns information about a file or directory

typescript

const stats = await fs.stat('./file.txt');
console.log(stats.isDirectory(), stats.size);

rename

fs.rename(oldPath, newPath): Promise<void>

Renames or moves a file or directory

typescript

await fs.rename('./old.txt', './new.txt');

copyFile

fs.copyFile(src, dest[, mode]): Promise<void>

Asynchronously copies a file from src to dest

typescript

await fs.copyFile('./source.txt', './backup.txt');

path - Path Utilities

join

path.join(...paths): string

Joins path segments using the platform-specific separator

typescript

path.join('/users', 'john', 'docs'); // '/users/john/docs'

resolve

path.resolve(...paths): string

Resolves a sequence of paths into an absolute path

typescript

path.resolve('src', 'index.js'); // '/home/user/project/src/index.js'

dirname

path.dirname(path): string

Returns the directory name of a path

typescript

path.dirname('/users/john/file.txt'); // '/users/john'

basename

path.basename(path[, suffix]): string

Returns the last portion of a path, optionally removing a suffix

typescript

path.basename('/users/file.txt', '.txt'); // 'file'

extname

path.extname(path): string

Returns the extension of a path including the dot

typescript

path.extname('index.html'); // '.html'

parse

path.parse(path): { root, dir, base, ext, name }

Returns an object with path components

typescript

path.parse('/home/user/file.txt');
// { root: '/', dir: '/home/user', base: 'file.txt', ext: '.txt', name: 'file' }

format

path.format(pathObject): string

Returns a path string from an object (opposite of parse)

typescript

path.format({ dir: '/home/user', name: 'file', ext: '.txt' });
// '/home/user/file.txt'

relative

path.relative(from, to): string

Returns the relative path from one path to another

typescript

path.relative('/data/users', '/data/files'); // '../files'

url - URL Handling

new URL

new URL(input[, base]): URL

Creates a new URL object by parsing the input relative to base

typescript

const url = new URL('/api/users', 'https://example.com');
// https://example.com/api/users

URL properties

url.href, url.origin, url.protocol, url.host, url.pathname, url.search, url.hash

Access and modify individual URL components

typescript

const url = new URL('https://site.com:8080/path?q=1#hash');
console.log(url.hostname, url.port, url.pathname);

searchParams.get

url.searchParams.get(name): string | null

Returns the first value of the specified search parameter

typescript

const url = new URL('https://site.com?id=123');
url.searchParams.get('id'); // '123'

searchParams.getAll

url.searchParams.getAll(name): string[]

Returns all values for a search parameter as an array

typescript

const url = new URL('?tag=js&tag=node');
url.searchParams.getAll('tag'); // ['js', 'node']

searchParams.set

url.searchParams.set(name, value): void

Sets the value of a search parameter, replacing existing values

typescript

url.searchParams.set('page', '2');

searchParams.append

url.searchParams.append(name, value): void

Appends a new name-value pair to the query string

typescript

url.searchParams.append('filter', 'active');

searchParams.delete

url.searchParams.delete(name): void

Removes all values for the specified parameter

typescript

url.searchParams.delete('temp');

searchParams.has

url.searchParams.has(name): boolean

Returns true if the parameter exists

typescript

url.searchParams.has('id'); // true

searchParams iteration

url.searchParams.entries() | keys() | values() | forEach()

Iterate over all search parameters

typescript

for (const [key, val] of url.searchParams) {
  console.log(key, val);
}

crypto - Cryptography

randomBytes

crypto.randomBytes(size): Buffer

Generates cryptographically strong random bytes

typescript

const token = crypto.randomBytes(32).toString('hex');

randomUUID

crypto.randomUUID(): string

Generates a random RFC 4122 version 4 UUID

typescript

const id = crypto.randomUUID();
// 'f47ac10b-58cc-4372-a567-0e02b2c3d479'

createHash

crypto.createHash(algorithm): Hash

Creates a Hash object for generating hash digests

typescript

const hash = crypto.createHash('sha256')
  .update('password')
  .digest('hex');

createHmac

crypto.createHmac(algorithm, key): Hmac

Creates an HMAC object for generating keyed hash digests

typescript

const hmac = crypto.createHmac('sha256', 'secret-key')
  .update('message')
  .digest('hex');

timingSafeEqual

crypto.timingSafeEqual(a, b): boolean

Compares two buffers in constant time to prevent timing attacks

typescript

const a = Buffer.from(userToken);
const b = Buffer.from(storedToken);
const isValid = crypto.timingSafeEqual(a, b);

Hash.update

hash.update(data[, encoding]): Hash

Updates the hash content with the given data

typescript

hash.update('part1').update('part2');

Hash.digest

hash.digest([encoding]): Buffer | string

Calculates the digest of all data passed to the hash

typescript

const result = hash.digest('base64');

events - EventEmitter

new EventEmitter

new EventEmitter(): EventEmitter

Creates a new EventEmitter instance

typescript

import { EventEmitter } from 'events';
const emitter = new EventEmitter();

emitter.on(eventName, listener): this

Adds a listener function for the specified event

typescript

emitter.on('data', (payload) => {
  console.log('Received:', payload);
});

once

emitter.once(eventName, listener): this

Adds a one-time listener that is removed after first invocation

typescript

emitter.once('connect', () => {
  console.log('Connected!');
});

emit

emitter.emit(eventName[, ...args]): boolean

Synchronously calls each listener registered for the event

typescript

emitter.emit('data', { id: 1, name: 'test' });

off

emitter.off(eventName, listener): this

Removes the specified listener from the event

typescript

emitter.off('data', myHandler);

removeAllListeners

emitter.removeAllListeners([eventName]): this

Removes all listeners for the specified event or all events

typescript

emitter.removeAllListeners('data');

listenerCount

emitter.listenerCount(eventName): number

Returns the number of listeners for the specified event

typescript

const count = emitter.listenerCount('data');

eventNames

emitter.eventNames(): (string | symbol)[]

Returns an array of event names with registered listeners

typescript

const events = emitter.eventNames(); // ['data', 'error']

os - Operating System

platform

os.platform(): string

Returns the operating system platform

typescript

os.platform(); // 'darwin', 'linux', 'win32'

arch

os.arch(): string

Returns the CPU architecture

typescript

os.arch(); // 'x64', 'arm64'

homedir

os.homedir(): string

Returns the path to the current user's home directory

typescript

os.homedir(); // '/Users/john' or 'C:\\Users\\john'

tmpdir

os.tmpdir(): string

Returns the operating system's default temp directory

typescript

os.tmpdir(); // '/tmp' or 'C:\\Users\\john\\AppData\\Local\\Temp'

cpus

os.cpus(): os.CpuInfo[]

Returns an array of objects with info about each logical CPU core

typescript

const numCores = os.cpus().length;
const model = os.cpus()[0].model;

freemem

os.freemem(): number

Returns the amount of free system memory in bytes

typescript

const freeGB = (os.freemem() / 1024 ** 3).toFixed(2);

totalmem

os.totalmem(): number

Returns the total amount of system memory in bytes

typescript

const totalGB = (os.totalmem() / 1024 ** 3).toFixed(2);

hostname

os.hostname(): string

Returns the hostname of the operating system

typescript

os.hostname(); // 'my-macbook.local'

type

os.type(): string

Returns the operating system name

typescript

os.type(); // 'Darwin', 'Linux', 'Windows_NT'

Node.js Built-ins Cheatsheet

fs/promises - File System

path - Path Utilities

url - URL Handling

crypto - Cryptography

events - EventEmitter

os - Operating System

Related Content