NodeJS Core Modules / Express Documentation

References

• fs: File system operations (reading, writing, deleting, etc.).
• path: Working with file paths.
• os: Operating system-related information and operations.
• http: Creating HTTP servers and clients.
• https: Creating HTTPS servers and clients.
• url: Parsing and manipulating URLs.
• events: Event-driven programming.
• stream: Handling streams of data.
• crypto: Cryptographic operations.
• util: Utility functions.
• net: Networking operations.
• child_process: Spawning child processes.
• assert: Assertions for testing.
• buffer: Handling binary data.
• querystring: Parsing and formatting query strings.
• timers: Scheduling functions (e.g., setTimeout, setInterval).

File System

The node:fs module enables interacting with the file system in a way modeled on standard POSIX functions. All file-system operations have synchronous, callback, and promise-based forms, and are accessible using both CommonJS syntax and ES6 Modules.

• Promise-based operations return a promise that is fulfilled when the asynchronous operation is complete.
• The callback form takes a completion callback function as its last argument and invokes the operation asynchronously. The arguments passed to the completion callback depend on the method, but the first argument is always reserved for an exception. If the operation is completed successfully, then the first argument is null or undefined.
• The synchronous APIs block the Node.js event loop and further JavaScript execution until the operation is complete. Exceptions are thrown immediately cand can be handled using try...catch.

A <FileHandle> object is an object wrapper for a numeric file descriptor.

A fs.Dir class represents a directory stream.

A fs.Dirent class is a representation of a directory entry, which can be a file or a subdirectory within the directory, as returned by reading from a fs.Dir. The directory entry is a combination of the file name and file type pairs.

A fs.Stats object provides information about a file.

Path

The default operation of the node:path modules varies based on the operation system on which a Node.js application is running. Specifically when running on a Windows operating system, the node:path module will assume that Windows-style paths are being used.

os

The node:os module provides operating system-related utility methods and properties.

http

This module, containing both a client and server, can be imported via require('node:http') or import * as http from 'node:http'. The HTTP interfaces in Node.js are designed to support many features of the protocol which have been traditionally difficult to use. In particular, possibly chunk-encoded, messages. The interface is careful to never buffer entire requests or responses, so the user is able to steam data. In order to support the full spectrum of HTTP applications, the Node.js HTTP API is very low-level. It deals with stream handling and message parsing only. It parses messages into headers and body but it does not parse the actual headers or the body.

The http.Agent class is responsible for managing connection persistence and reuse for HTTP clients. It maintains a queue of pending requests for a given host and port, reusing a single socket connection for each until the queue is empty, at which time the socket is either destroyed or put into a pool where it is kept to be used again for requests to the same host and port. Whether it is destroyed or pooled depends on the keepAlive option. Pooled connections have TCP Keep-Alive enabled for them, but servers may still close idle connections, in which case they will be removed form the pool and a new connection will be made when a new HTTP request is made for that host and port. Servers may also refuse to allow multiple requests over the same connection, in which the connection will have to be remade for every request and cannot be pooled. The Agent will still make the requests to that server, but each one will occur over a new connection.

When a connection is closed by the client or the server, it is removed from the pool. Any unused sockets in the pool will be unrefed so as to not keep the Node.js process running when there are no outstanding requests. It is good practice to destroy an agent instance when it is no longer in use, because unused sockets consume OS resources.

https

HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented in a separate module.

url

The node:url module provides utilities for URL resolution and parsing. A URL string is a structured string containing multiple meaningful components. When parsed, a URL object is returned containing properties of each of these components. The node:url module provides two APIs for working with URLs: a legacy API that is Node.js specific, and a newer API that implements the same WHATWG URL Standard used by web browsers.

events

Much of the Node.js core API is built around idiomatic asynchronous event-driven architecture in which certain kinds of objects (called emitters) emit named events that cause Function objects (listeners) to be called. All objects that emit events are instances of the EventEmitter class. These objects expose an eventEmitter.on() function that allows one or more functions to be attached to named events emitted by the object. Typically, event names are camel-cased strings but any valid JavaScript property key can be used. When the EventEmitter object emits an event, all of the functions attached to that specific event are called synchronously. Any values returned by the called listeners are ignored and discarded. If an EventEmitter does not have at least one listener registered for the error event, and an 'error' event is emitted, the error is thrown, a stack trace is printed, and the Node.js process exits. As a best practice, listeners should always be added for the 'error' events.

stream

A stream is an abstract interface for working with streaming data in Node.js. The node:stream module provides an API for implementing the stream interface. Streams can be readable, writable, or both.

There are four types of stream types within Node.js:

1. Writable: streams to which data can be written
2. Readable: streams from which data can be read
3. Duplex: streams that are both Readable and Writable
4. Transform: Duplex streams that can modify or transform the data as it is written and read.

All streams created by Node.js APIs operate exclusively on strings, Buffer, TypedArray, and DataView objects:

• • Strings and Buffers are most common types used with streams
  • TypedArray and DataView lets you handle binary data with types like Int32Array or Uint8Array. When you write a TypedArray or a DataView to a stream, Node.js processes the raw bytes.

Both writable and readable streams will store data in an internal buffer.

Writable streams are an abstraction for a destination to which data is written. While specific instances of Writable streams may differ in various ways, all Writable streams follow the same fundamental usage pattern illustrated below:

const myStream = getWritableStreamSomehow();
myStream.write('some data');
myStream.write('some more data');
myStream.end('done writing data'); 

Readable streams are an abstraction for a source from which data is consumed. Readable streams effectively operate in one of two modes: flowing and paused. A Readable stream can be in object mode or not, regardless of whether it is in flowing mode or paused mode.

• In flowing mode, data is read from the underlying system automatically and provided to an application as quickly as possible using events via the EventEmitter interface.
• In paused mode, the stream.read() method must be called explicitly to read chunks of data from the stream.

All Readable streams begin in paused mode but can be switched to flowing mode and back to paused mode.

Can switch from flowing to paused by:

• Adding a 'data' event handler
• Calling the stream.resume() method
• Calling the stream.pipe() method to send the data to a Writable

Can switch from paused to flowing by:

• If there are no pipe destinations, by calling the stream.pause() method.
• If there are no pipe destinations, by removing all pipe destinations. Multiple pipe destinations may be removed by calling the stream.unpipe() method.

crypto

The node:crypto module provides cryptographic functionality that includes a set of wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify functions.

util

The node:util module supports the needs of Node.js internal APIs. Many of the utilities are useful for application and module developers as well.

net

The node:net module provides an asynchronous network API for creating stream-based TCP or IPC servers and clients.

child_process

The node:child_process module provides the ability to spawn subprocesses in a manner that is similar, but not identical, to popen(3). This capability is provided by the child_process.spawn() function. By default, pipes for stdin, stdout, and stderr are established between the parent Node.js process and the spawned subprocess. These pipes have limited (and platform-specific) capacity. If the subprocess writes to stdout in excess of that limit without the output being captured, the subprocess blocks waiting for the pipe buffer to accept more data. The child_process.spawn() method spawns the child process asynchronously, without blocking the Node.js event loop.

buffer

Buffer objects are used to represent as fixed-length sequence of bytes. Many Node.js APIs support Buffers. The Buffer class if a subclass of JavaScript's <Uint8Array> class and extends it with methods that cover additional use cases. node.js APIs accept plain <Uint8Array>s whenever Buffers are supported as well. While the Buffer class is available within the global scope, it is still recommended to explicitly reference it via an import or require statement.

When converting between Buffers and strings, a character encoding may be specified.

querystring

The node:querystring module provides utilities for parsing and formatting URL query strings.

timers

The timer module exposes a global APU for scheduling functions to be called at some future period of time. Because the timer functions are global, there is no need to call require('node:timers') to use the API. The timer functions within Node.js implement a similar API as the timers API provided by Web Browsers but use a different internal implementation that is built around the Node.js Event Loop.

Express

Fast, unopinionated, minimalist web framework for Node.js.

The app.locals object has properties that are local variables within the application, and will be available in templates rendered with res.render.