NPM private repository configuration

When internal development requires sharing private modules, an NPM private repository can securely store and distribute private packages, control access permissions, accelerate dependency installation, and unify internal dependency version management. Common solutions include the lightweight Verdaccio, the feature-rich Nexus Repository, and GitHub Packages, which integrates deeply with GitHub. Verdaccio configuration covers basic setup, user authentication, and package publishing. Clients can use the private repository via global or project-level configuration. Advanced configurations involve the plugin system, HTTPS, and cluster deployment. When integrating with CI/CD, GitHub Actions can be configured. Performance optimization includes caching strategies and storage optimization. Monitoring and maintenance involve log analysis and health checks. Migrating existing packages can be done by downloading from public repositories and republishing or using batch migration tools. Common issues include permission problems, proxy issues, and insufficient storage space.

NPM dependency management

NPM is the package management tool for Node.js, used to install, manage, and share JavaScript code. It manages project dependencies through the package.json file, including three types: dependencies, devDependencies, and peerDependencies. NPM uses semantic versioning for dependency packages, supporting various version range specifications. Dependencies are installed using the `npm install` command, and package-lock.json ensures dependency version consistency. Global installation is suitable for command-line tools, while local installation is for project dependencies. NPM can automatically resolve dependency conflicts and provides security auditing features. Custom scripts simplify the development process. Publishing an NPM package requires following specific steps, and the workspace feature supports multi-package management. Yarn and pnpm are alternatives to NPM, optimizing dependency management. Regular updates, using `npm ci`, and removing unused dependencies are recommended. Debugging dependency issues involves various techniques. International projects need to consider language support. Dependency selection impacts performance and requires careful consideration. Testing strategies ensure update stability. Documenting dependency information is essential, and long-term projects need a dependency maintenance plan.

Global installation and local installation

Node.js's package manager npm provides two installation methods: global and local. Globally installed packages are placed in the system directory and can be used directly in the command line, making them suitable for command-line tools. Locally installed packages are placed in the project's `node_modules` and are limited to the current project, making them suitable for project dependencies. Global installation is convenient but may cause version conflicts, while local installation ensures version isolation but requires repeated installations. `npx` can temporarily run packages to avoid global pollution. Best practices include: - Command-line tools can be installed globally. - Project dependencies must be installed locally. - One-time tools should prioritize `npx`. - Team projects should specify dependency versions in `package.json`. - If issues arise, check globally installed packages or use version management tools like `nvm`. - Project collaboration requires lock files to ensure dependency consistency. - Dependency types include production, development, peer, and optional. - Installation optimization can use mirror sources, Yarn, or pnpm. - Regularly run security audits to check for vulnerabilities.

NPM scripts

NPM scripts are a crucial part of Node.js projects, defined through the `scripts` field in `package.json`, simplifying development workflows and automating tasks. Basic usage includes defining and executing scripts, such as `npm run test` to run Jest test scripts. They support composition and hooks, with `pre` and `post` automatically executing pre- and post-operations. Environment variables and parameter passing can be achieved via `process.env`, while cross-platform compatibility is addressed using `cross-env` to resolve system differences. Complex scripts can be modularized into standalone JS files and integrated with tools like Webpack and Mocha. Performance optimization can be achieved by running scripts in parallel with `npm-run-all`. For debugging, use `--silent` to reduce logs or `nodemon` for auto-restarting. In real-world projects, scripts cover multiple stages, including development, building, testing, and deployment.

Semantic Versioning

Semantic Versioning (SemVer) is a version numbering specification consisting of three numbers: MAJOR, MINOR, and PATCH, representing the major version, minor version, and patch number, respectively. Incrementing the major version indicates incompatible API changes, the minor version indicates backward-compatible feature additions, and the patch number indicates backward-compatible bug fixes. Pre-release versions and build metadata can be represented by appending identifiers. In Node.js's package.json, dependency version ranges can be specified using symbols, such as allowing updates to MINOR and PATCH (^) or only allowing PATCH updates (~). Publishing new versions can be automated using the `npm version` command. Version conflicts can be resolved by updating dependencies or forcibly specifying versions. Best practices include starting formal releases from 1.0.0, updating version numbers promptly, using version ranges appropriately, and documenting changes.

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.