Common NPM commands

NPM is the package management tool for Node.js, used to install, manage, and share JavaScript code. Common commands include initializing a project with `npm init`, which can quickly generate default configurations using `npm init -y`. Installing dependencies is categorized into production dependencies (`npm install lodash`), development dependencies (`npm install jest --save-dev`), and global installations (`npm install nodemon -g`). To uninstall dependencies, use `npm uninstall lodash`. Updating dependencies can be done with `npm update lodash` or checking for outdated packages with `npm outdated`. Running scripts is done via `npm run test`. To view package information, use `npm list` or `npm view express`. Publishing a package requires logging in first with `npm login` and then using `npm publish`. Configuring NPM includes setting the registry mirror with `npm config set registry` and clearing the cache with `npm cache clean --force`. Other commands include security checks (`npm audit`), temporarily running packages (`npx create-react-app`), and viewing help (`npm help`).

Detailed explanation of the package.json file

The package.json is the core configuration file of a Node.js project, written in JSON format and located in the project's root directory. It defines project metadata, dependencies, script commands, and more. The basic structure includes fields such as `name`, `version`, `description`, and `main`, where `name` and `version` are mandatory and together form the project's unique identifier. Dependency management is divided into different scopes like `dependencies`, `devDependencies`, and `peerDependencies`. The `scripts` field defines executable npm scripts, including common commands and lifecycle hooks. Advanced configurations include environment and publishing controls such as `engines`, `os`, and `files`. It also supports `workspaces` for multi-package management and custom field configurations. A complete example demonstrates the full structure of a typical package.json file.

Basic concepts of packages and NPM

Node.js packages are reusable code modules that include a package.json file describing metadata such as name, version, dependencies, etc. NPM is the Node.js package manager, used to install and manage dependency packages, supporting global installation, development dependencies, and the creation and publishing of packages. Common commands include `install`, `update`, `list`, etc. In package.json, `dependencies` and `devDependencies` distinguish between environment-specific dependencies, while `scripts` defines runtime commands. Version numbers follow semantic versioning to control package scope, supporting organizational management. The node_modules structure has evolved from nested to flat. Modern tools like Yarn and pnpm offer alternative solutions. Private packages require authentication for installation, and security considerations include `audit` checks and vulnerability fixes. Development techniques involve `npm link` for local testing, while the publishing process incorporates continuous integration and automated testing.

The difference between module.exports and exports

In the Node.js module system, the core difference between `module.exports` and `exports` lies in the fact that the former is the actual exported object, while the latter is merely its initial reference. Directly assigning a value to `exports` will sever this connection, causing the export to fail, whereas modifying `module.exports` will completely replace the exported content. The article provides a detailed analysis of their underlying mechanisms, demonstrates correct usage through practical scenarios, highlights common misconceptions, and contrasts the differences with ES6 modules. Finally, it offers best practices for various export patterns to help developers write more reliable modular code.

The require mechanism and module loading process

The require mechanism in Node.js is the core part of the module system, based on the CommonJS specification, using synchronous loading. It supports various module types, including core modules, file modules, directory modules, and node_modules modules. The loading process involves path resolution, cache checking, file loading, module compilation, and cache storage. The module caching mechanism improves performance. Circular dependency handling returns incompletely initialized modules. The lookup algorithm recursively searches upward from the current directory for node_modules. Each module has an independent scope, implemented through function wrapping. require.resolve can resolve module paths without loading the module. Custom require functions can be implemented by modifying the Module prototype. Module hot replacement is achieved by clearing the cache and reloading. ES modules and CommonJS can interoperate but require attention to differences. Debugging module loading can be done by setting environment variables. Performance optimizations include organizing module structures reasonably, caching core modules, and avoiding dynamic require. Security considerations include avoiding direct require of user input. When used with TypeScript, attention must be paid to type declarations and module resolution strategies. Performance analysis can be performed using built-in performance hooks or third-party tools.

Classification of modules (core modules, file modules, third-party modules)

Node.js modules are divided into core modules, file modules, and third-party modules. Core modules are built-in foundational modules in Node.js, such as `fs` and `http`, which can be loaded directly without installation and offer optimal performance. File modules are custom modules created by developers, loaded via relative or absolute paths, and can be either a single file or a directory containing `index.js`. Third-party modules are installed via npm and stored in `node_modules`, providing specific functionalities to address domain-specific problems. Node.js follows the CommonJS specification for module loading, with a specific search order: core modules are prioritized first, followed by modules in `node_modules`. Each module has an independent scope and exposes interfaces via `module.exports`. Node.js supports the coexistence of ES modules and CommonJS and can handle circular dependencies. It also offers various debugging techniques, such as inspecting module paths and clearing the cache.

The Node.js REPL environment translates this sentence into English.

The Node.js REPL environment is an interactive interpreter that allows developers to quickly test code snippets, debug, and explore APIs. It provides instant feedback, making it ideal for learning and experimentation. REPL stands for Read-Eval-Print Loop and is Node.js's built-in interactive programming environment. When you enter `node` without any arguments in the command line, you enter REPL mode. This environment reads input, executes it, prints the result, and loops to wait for the next input. The REPL environment includes several special variables, such as `_` (which holds the result of the last expression), `.exit` (to quit), `.break` (to exit multi-line input), `.clear` (to reset the context), and `.editor` (to enter editor mode). Node.js allows the creation of custom REPL environments via the `repl` module, supporting the injection of custom variables and functions. The REPL environment supports modern JavaScript features, including `async/await`, and provides detailed error stack traces. In the REPL, you can directly `require` installed npm modules. While REPL is great for quick testing, performance considerations should be noted. It is well-suited for practical scenarios like API exploration, algorithm validation, and data transformation. Compared to browser consoles and Python REPL, the Node.js REPL has unique advantages. When launching the REPL, various options can be passed or configured in code. The REPL automatically detects multi-line input or allows entering a dedicated editor mode via the `.editor` command. When using the REPL, security should be a priority—avoid exposing it on production servers. The REPL can be used alongside debuggers, profilers, and other tools. Behavior may vary across Node.js versions. Common issues like input freezing or undefined variables have corresponding solutions. Performance can be optimized by preloading frequently used modules, disabling colors, or limiting history size.

The global object in Node.js

In the Node.js runtime environment, there are global objects that can be used directly without requiring them. These objects are shared across different modules and provide basic API functionality. `global` is the top-level global object, and all global variables (except `module`) are its properties. The `process` object provides an interface to interact with the current process, including environment variables, process control, standard I/O, and performance analysis. The `console` object offers formatted output, timing functions, and stack tracing. Timer functions include one-time, periodic timers, and immediate execution. The `Buffer` class handles binary data. `__filename` and `__dirname` provide the current module's path information. `module`, `exports`, and `require` are core components of the module system. The `URL` class, `TextEncoder`, `TextDecoder`, and `performance` are also important global objects. The module system affects the visibility of global variables, with each module having its own scope. The true global object can be accessed via `globalThis`.

Node.js version management tools (nvm/n)

Node.js version management tools like nvm and n help developers efficiently switch between different Node versions to resolve compatibility issues across multiple projects. nvm supports macOS, Linux, and Windows, and can be installed via scripts, allowing parallel management of multiple versions with quick switching and isolated environments. n, on the other hand, only supports macOS and Linux, is installed via npm, and has a more lightweight design. The two tools differ significantly in cross-platform support, installation methods, and version isolation. The article provides a detailed explanation of their installation processes, common commands, and practical use cases, such as project version synchronization and CI configuration. It also offers practical tips like mirror acceleration, global module management, and version aliasing. Finally, it covers advanced usage such as custom installation paths and auto-loading.

The difference between Node.js and browser JavaScript

Node.js and browser JavaScript, although based on the same ECMAScript standard, exhibit significant differences in runtime environment APIs, module systems, and other aspects. Node.js runs on the server side, providing OS-level APIs such as file system access, while browser JavaScript operates in a client-side sandboxed environment constrained by security policies. Their global objects differ: Node.js uses `global` and `process`, whereas browsers use `window` and `document`. In terms of module systems, Node.js adopts CommonJS, while browsers support ES modules. Their networking APIs also vary: Node.js provides the `http` module, whereas browsers offer `fetch` and `XMLHttpRequest`. The event loop mechanisms differ as well—Node.js has six distinct phases, while browsers handle it more simply, primarily managing macro-tasks and micro-tasks. Debugging tools are distinct too: Node.js uses the `inspect` parameter, while browsers rely on developer tools. Performance-wise, Node.js excels in high-concurrency I/O, whereas browsers are limited by user device capabilities. Security restrictions differ: Node.js can access local resources, while browsers adhere to the same-origin policy. Their package management ecosystems also diverge—Node.js uses npm, while browsers rely on `<script>` tags or CDNs. Both support async/await for asynchronous programming, but their traditional styles differ: Node.js leans toward callbacks, while browsers favor Promises. Memory management also varies: Node.js allows manual garbage collection triggering, whereas browsers handle it entirely automatically.