Fundamentals of Modularity

Modularity is the architectural approach of decomposing complex systems into hierarchical, self-contained units. This structure enables components to be interchangeable, reusable, and easier to maintain. By adhering to standardized syntax rules for exposing interfaces, developers reduce integration overhead and ensure consistency across different parts of the application.

Core Module Architecture in Node.js

Node.js categorizes resources into three distinct groups based on origin:

1. Core Modules: Native APIs provided directly by the runtime (e.g., fs, path).
2. Custom Modules: Any .js file created within the project directory.
3. Third-Party Packages: External libraries managed via a package manager before use.

To utilize these resources, the synchronous require() function is employed. It is important to note that calling require() triggers immediate execution of the target module's code.

// core_module_usage.js
const pathUtils = require('path'); // Accessing built-in API
const userLogic = require('./logic/userHandler'); // Loading local script
const utilsLib = require('lodash'); // Utilizing external library

Scope and Isolation

Variables declared at the top level of a module possess file-level scope, effectively preventing pollution of the global namespace. To share functionality with other scripts, modules must explicitly export members.

Exporting Members The module.exports object serves as the public interface. Assignments made here become accessible to importing files.

// logic/userHandler.js
let internalState = 'private';

function authenticate(credentials) {
  return credentials.length > 0;
}

module.exports.checkAuth = authenticate;
module.exports.secretKey = null; // Intentionally hidden

Managing Exports: exports vs module.exports

The exports variable is a reference to module.exports. However, reassigning exports creates a new reference, breaking the link to the actual export object. Only properties should be added to module.exports directlly.

// Avoid this pattern
// exports = { hello: 'world' } // Broken connection

// Preferred pattern
module.exports.hello = 'world'; // Correct usage

The NPM Ecosystem

Third-party packages accelerate development by providing high-level abstractions over low-level Node.js APIs. The official registry is hosted at https://registry.npmjs.org/, hosting millions of open-source components.

Installation Artifacts

Running installation commands generates specific project artifacts:

• node_modules/: Stores the actual code for all installed dependencies.
• package-lock.json: Records the exact dependency tree version and integrity hashes to guarantee reproducible environments.

Dependency Classification

Project configuration resides in package.json. Dependencies are split based on lifecycle needs:

• dependencies: Required for both production and development phases.
• devDependencies: Tools utilized only during the build or testing phase.

# Install a production library
npm install express --save

# Install a development tool
npm install jest --save-dev

Version Control Strategy

NPM utilizes Semantic Versioning (SemVer): Major.Minor.Patch.

• Major: Breaking changes.
• Minor: New backward-compatible features.
• Patch: Bug fixes.

Optimizing download speeds is critical for international users. Switching from the default US registry to a domestic mirror can significantly reduce latency.

nrm use taobao

Module Resolution Mechanics

Modules are cached after their first load. Subsequent require() calls return the cached instance, enhancing performance regardless of whether the module is core, custom, or third-party.

Resolution Hierarchy

When resolving a module identifier, Node.js follows this order:

1. Core Check: Verify if it matches a built-in module name.
2. Filesystem Check: If the identifier starts with ./ or ../, attempt to resolve relative paths. Extension defaults include .js, .json, and .node.
3. Package Search: If no path prefix exists, traverse node_modules directories starting from the current location up to the filesystem root.

Directory Handling

When a directory is passed to require():

1. Look for main property in the directory's package.json.
2. If missing or invalid, default to loading index.js within that folder.
3. Throw an error if the resolution fails completely.

This structured approach ensures reliable identification and loading of code dependencies across complex project structures.