npm 是 Node.js 附带的包管理器。它可用于安装和发布 CommonJS 和 ECMAScript 模块、jQuery 插件、可重用 JavaScript 代码（库）、基于 JavaScript 的 CLI 程序等。

在Visual Studio Code中运行需要管理员权限的命令确实需要一些特定的步骤，因为默认情况下，VS Code的终端并不以管理员权限运行。下面我将详细说明如何实现这一点：

1. **以管理员身份运行Visual Studio Code**:
   - 在Windows上，您可以通过右键点击Visual Studio Code的快捷方式或可执行文件，然后选择“以管理员身份运行”来启动VS Code。这样，当您打开新的终端窗口时，它将自动具有管理员权限。
   - 在macOS或Linux上，通常需要在终端中使用`sudo`命令来提升权限。虽然VS Code本身不需要以root用户运行，但您可以在VS Code的终端中使用`sudo`来执行需要提高权限的命令。

2. **在已有的VS Code实例中打开一个新的以管理员权限运行的终端**:
   - 如果VS Code已经在运行中，并且没有以管理员权限启动，您可以在Windows上打开一个新的命令提示符或PowerShell窗口，以管理员身份运行，然后从那里运行`code`命令来重新启动VS Code。例如，在管理员的命令提示符中输入`code`。
   - 另一个方法是关闭当前的VS Code，然后按照上述方法重新以管理员权限启动它。

3. **使用终端中的`sudo`命令**:
   - 对于Linux和macOS用户，在VS Code的终端中执行需要管理员权限的命令时，可以在命令前加上`sudo`。例如，如果您需要安装一个全局的npm包，可以使用命令`sudo npm install -g <package_name>`。

例如，如果我需要在Windows上以管理员权限安装一个全局的Node.js包，我会这样做：

1. 确保VS Code已经以管理员权限启动。
2. 打开一个新的终端窗口。
3. 输入命令`npm install -g <package_name>`。

这样，我就能确保以管理员权限执行命令，避免权限不足的问题。希望这能帮到您！

如何使用Visual Studio代码终端运行具有管理员权限的命令？

在使用 npm 时，修改全局的注册源通常是为了提高安装依赖时的速度或是切换到一个更合适的源上。重置或更改全局的 npm 注册源可以通过以下步骤进行：

1. **查看当前注册源**：
   你首先可以通过命令行查看当前的注册源，这可以帮助你确认当前使用的是哪一个源。可以使用以下命令：
   ```
   npm config get registry
   ```

2. **重置为 npm 默认注册源**：
   如果你想要将注册源重置为 npm 的默认源，你可以使用以下命令：
   ```
   npm config set registry https://registry.npmjs.org/
   ```

   这个命令将全局的 npm 注册源设置为 npm 官方的源。

3. **验证更改**：
   更改注册源后，你可以重新运行 `npm config get registry` 来确认注册源已成功更改。

例如，如果你之前设置了使用淘宝的 npm 镜像（这是中国大陆开发者常用的一个 npm 镜像源，因为它比官方源更快），你可能会看到如下配置：
```
https://registry.npmmirror.com/
```

执行重置命令后，再次查看注册源应显示：
```
https://registry.npmjs.org/
```

这样，你就成功重置了全局的 npm 注册源。这个操作对于解决一些依赖安装问题或是在不同地区开发时切换最优的源都是非常有用的。

NPM 如何重置全局的 npm register 注册源？

在`package.json`文件中，通常我们不直接指定`node_modules`的路径。`node_modules`的路径默认是在项目的根目录下。如果需要改变`node_modules`的存放路径，通常是通过配置`npm`或`yarn`的行为来实现，而不是在`package.json`中直接设置。

### 使用环境变量改变路径

一种方法是通过设置环境变量`NODE_PATH`来指定额外的查找路径，这样`node`在解析模块时会加入这个路径。例如，在Linux或Mac系统中，可以在启动应用之前设置：

```bash
export NODE_PATH=/path/to/custom/node_modules
node app.js
```

在Windows系统中，设置的命令可能如下：

```bash
set NODE_PATH=C:\path\to\custom\node_modules
node app.js
```

### 使用.npmrc文件配置

另一种方法是使用`.npmrc`文件来配置`node_modules`的路径。虽然这不是直接在`package.json`中设置，但它允许你在项目级别或用户级别改变`npm`的行为。在`.npmrc`文件中，你可以设置：

```
prefix=/path/to/custom/node_modules
```

这将改变全局安装的位置，也就是说，当你使用`npm install -g <package>`时，包将被安装到你指定的路径。

### 使用 npm 配置命令

可以通过npm的配置命令直接在命令行中设置：

```bash
npm config set prefix /path/to/custom/node_modules
```

这样也会改变模块的安装路径。

### 结论

虽然直接在`package.json`中设置`node_modules`的路径不是标准做法，但通过上述方法可以有效地控制依赖包的存储位置。这样的配置通常用于解决特定环境的约束，或者在多个项目之间共享同一套`node_modules`来节省空间。

Package . Json 中如何指定 node_modules 的路径

在Node.js中，获取某个文件所在的文件夹路径可以通过`path`模块来实现。`path`模块是Node.js的核心模块之一，提供了一系列用于处理和转换文件路径的工具。

例如，如果我们有一个文件路径，并且我们想要找到这个文件的文件夹路径，我们可以使用`path.dirname()`方法。这个方法会返回一个路径的目录名。

下面是一个具体的例子：

```javascript
// 导入path模块
const path = require('path');

// 假设我们有一个文件路径
const filePath = '/users/openai/documents/example.txt';

// 使用path.dirname()方法获取文件所在的文件夹路径
const directory = path.dirname(filePath);

// 打印文件夹路径
console.log(directory);  // 输出: /users/openai/documents
```

在这个例子中，我们首先导入了Node.js的`path`模块。然后，我们定义了一个文件的完整路径`filePath`。使用`path.dirname()`方法，我们能够从完整的文件路径中提取出文件所在的文件夹路径，并将其存储在变量`directory`中。最后，我们打印出这个文件夹路径，结果显示文件`example.txt`位于`/users/openai/documents`文件夹中。

通过这种方式，我们可以很方便地在Node.js应用中处理和分析文件路径。这在开发中是非常常见的需求，比如在读取、写入文件或者管理文件系统时。

Node js如何获取某个文件所在的文件夹路径？

当遇到npm漏洞时，手动修复通常涉及以下几个步骤：

### 1. 识别漏洞
首先，我们需要确切地了解哪些依赖包含漏洞。可以使用`npm audit`命令来帮助识别项目中的安全漏洞。这个命令会扫描项目的依赖，并报告任何已知的漏洞。

例如：
```bash
npm audit
```

### 2. 分析报告
`npm audit`命令会提供一个详细报告，说明哪些包含漏洞的包，漏洞的严重性，以及可能存在的修复方案。你需要仔细阅读这些报告，了解哪些是需要立即修复的。

### 3. 升级有漏洞的包
一般来说，修复漏洞最直接的方法是升级到一个没有漏洞的版本。你可以使用`npm update <package-name>`来更新单个包。

例如：
```bash
npm update lodash
```

如果`npm audit`提供了修复建议，如使用特定版本，也可以直接按照建议操作。

### 4. 使用`npm audit fix`
对于一些自动可修复的漏洞，你可以使用`npm audit fix`命令。这个命令会尝试自动更新所有被识别的有漏洞的包到一个安全的版本。

例如：
```bash
npm audit fix
```

### 5. 手动替换或重写代码
如果自动修复失败，或者没有可用的安全版本，你可能需要手动替换有问题的包，或者直接修改有问题的代码片段。这可能涉及到阅读和理解源代码，以及可能的安全漏洞。

### 6. 测试和验证
修复漏洞后，确保运行全面的测试来验证应用程序的功能性和安全性没有受到影响。可以使用单元测试、集成测试等方法确保一切正常。

### 7. 监控和持续保护
最后，继续监控项目依赖的安全性，并定期使用`npm audit`检查新的安全漏洞。可以考虑集成到CI/CD流程中，确保在部署前漏洞能被发现并处理。

### 实例
在我之前的项目中，我们发现了一个关于`express`的安全漏洞。通过运行`npm audit`，我们定位到具体的漏洞和相关的依赖包。由于`express`是一个广泛使用的框架，我们首先尝试使用`npm audit fix`自动修复。这个命令帮助我们更新到了一个没有漏洞的新版本。之后，我们通过运行全套自动化测试来确保更新没有破坏现有功能。此外，我们还加强了代码审查和定期的安全培训，以提高团队的安全意识。

如何手动修复npm漏洞？

在Node.js和npm的环境中，全局路径前缀是指npm安装全局软件包的目录。了解这个路径对于配置系统环境变量、解决路径问题以及进行系统维护等都非常有用。

获取npm全局路径前缀的几种方法如下：

### 1. 使用npm命令

最直接的方法是使用npm自带的命令行工具来查询全局路径前缀。打开终端或命令提示符，输入以下命令：

```bash
npm config get prefix
```

这条命令会返回npm的全局安装路径前缀。例如，它可能返回类似 `/usr/local`或者 `C:\Users\用户名\AppData\Roaming\npm`这样的路径，这取决于你的操作系统和npm的配置。

### 2. 查看环境变量

在某些系统配置中，npm的全局路径可能会被设置在环境变量中。你可以通过查看环境变量来找到这个路径。具体方法依赖于你的操作系统：

- **Windows**: 打开命令提示符，输入 `echo %NPM_CONFIG_PREFIX%`。
- **Unix/Linux/Mac**: 打开终端，输入 `echo $NPM_CONFIG_PREFIX`。

如果这些环境变量被正确设置，它们会显示npm的全局路径前缀。

### 3. 查看npm配置文件

npm的配置也可以在用户目录下的 `.npmrc`文件或全局 `npmrc`文件中找到。你可以打开这些文件查看是否有设置 `prefix`的配置项。例如：

```bash
cat ~/.npmrc
```

或者

```bash
cat /etc/npmrc
```

这些文件中可能包含像 `prefix=/some/path`这样的行，指示全局安装路径前缀。

### 结论

通常来说，使用 `npm config get prefix`命令是最简单和直接的方法来查找npm的全局路径前缀。这种方法不仅快捷，而且不依赖于操作系统，因此在多种环境中都是有效的。

如何获取npm全局路径前缀

`yarn run` 和 `npm start` 都是现代前端开发中常用的命令，它们用于启动应用程序。然而，两者之间存在一些细微的差异：

1. **命令行工具**:
   - `npm start` 是 npm 包管理器的一部分，npm 是 Node.js 的默认包管理工具，自 Node.js 出现以来一直被广泛使用。
   - `yarn run` 是 Yarn 包管理器的命令，Yarn 是由 Facebook 开发，旨在解决 npm 的一些问题，如性能和安全性，自 2016 年以来被广泛采用。

2. **性能**:
   - Yarn 在性能方面通常被认为比 npm 更优越。这是因为 Yarn 在执行安装时生成一个 `yarn.lock` 文件，确保依赖项的版本控制更加准确和一致，同时 Yarn 的缓存机制也比 npm 更高效。
   - npm 在近年的版本中也做了很多优化，例如 npm 5 引入了 `package-lock.json`，它也尽力保持依赖版本的一致性。

3. **使用情景**:
   - `npm start` 通常在 `package.json` 文件中指向 `scripts` 对象里的 `start` 脚本。这是一个约定，用于启动应用程序的主要方式。
   - `yarn run` 同样读取 `package.json` 中的 `scripts` 对象，但它可以运行 `scripts` 对象中定义的任何脚本。例如，运行 `yarn run test` 将执行 `test` 脚本。

4. **跨平台兼容性**:
   - 在跨平台开发中，Yarn 和 npm 都很好地支持跨平台操作，减少了平台间的差异性。

5. **示例**:
   - 假设在一个 Node.js 项目中，`package.json` 的 `scripts` 部分可能如下所示：
     ```json
     {
       "scripts": {
         "start": "node app.js",
         "test": "mocha **/*.test.js"
       }
     }
     ```
   - 在这种情况下，使用 `npm start` 和 `yarn start` 都会执行 `node app.js`，启动应用程序。但若要运行测试，则分别使用 `npm run test` 和 `yarn run test`。

总结来说，虽然 `yarn run` 和 `npm start` 在功能上非常相似，主要差异在于它们所属的包管理工具（Yarn 或 npm）以及这些工具的性能和一些细节处理上的差异。选择哪一个通常取决于团队的偏好或特定项目的需求。

Yarn run 和npm start 之间有什么区别？

在不使用npm的情况下安装Node.js模块，可以通过以下几种方式：

### 1. 手动下载和安装

这是最直接的方法，可以手动下载模块的源代码，然后将其放在项目的 `node_modules` 文件夹中。

**步骤：**
1. 前往需要的Node.js模块的GitHub页面或其他代码托管服务网站。
2. 下载源代码（通常是ZIP文件）。
3. 解压缩文件到你的项目中的 `node_modules` 目录。
4. 在你的代码中通过 `require` 方式引用该模块。

**例子：**
假设需要安装 `lodash` 模块。
- 前往 https://github.com/lodash/lodash
- 下载ZIP文件并解压到项目的 `node_modules/lodash` 目录下
- 在代码中使用 `const _ = require('lodash');`

### 2. 使用Git

如果模块托管在Git仓库上，可以直接通过Git克隆的方式将模块下载到本地。

**步骤：**
1. 找到模块的Git仓库地址。
2. 使用 `git clone` 命令克隆仓库到本地的 `node_modules` 目录。
3. 根据需要，切换到特定的标签或分支。

**例子：**
安装 `express` 模块。
- 执行 `git clone https://github.com/expressjs/express.git node_modules/express`
- 切换到稳定版本 `cd node_modules/express && git checkout 4.17.1`

### 3. 使用其他包管理器

虽然不使用npm，但可以考虑使用其他JavaScript包管理器，如Yarn或pnpm等。

**步骤：**
1. 安装Yarn或pnpm。
2. 使用对应命令代替npm进行安装。

**例子：**
使用Yarn安装 `moment` 模块。
- 执行 `yarn add moment`

这些方法可以在不直接使用npm的情况下，实现Node.js模块的安装。每种方法都有其使用场景，选择合适的方法可以依据具体项目的需求和环境来定。

如何在不使用npm的情况下安装node.js模块？

在Windows上安装旧版本的Node.js可以通过多种方法实现，但最常见和推荐的方法是使用Node Version Manager (nvm) for Windows。这是一个方便的工具，可以让你在同一台机器上安装和管理多个Node.js版本。以下是详细的步骤：

### 步骤 1: 安装 NVM for Windows

1. 访问 [NVM for Windows](https://github.com/coreybutler/nvm-windows) 的GitHub页面。
2. 下载最新的安装程序，通常是名为 `nvm-setup.zip` 的文件。
3. 解压缩该文件并运行安装程序。安装过程中，你可以选择安装位置和其他配置选项。
4. 完成安装后，重新启动命令提示符以确保NVM命令可用。

### 步骤 2: 使用NVM安装Node.js的指定版本

1. 打开命令提示符或PowerShell。
2. 首先，你可以使用 `nvm list available` 命令查看可用的Node.js版本。
3. 使用NVM安装特定版本的Node.js，例如，如果你需要安装Node.js版本10.15.3，可以使用命令：
   ```
   nvm install 10.15.3
   ```
4. 安装完成后，你可以通过运行以下命令来切换到刚刚安装的版本：
   ```
   nvm use 10.15.3
   ```

### 步骤 3: 验证安装

1. 要检查当前使用的Node.js版本，可以在命令行中输入：
   ```
   node -v
   ```
   这应该显示你刚刚安装的版本号，如 `v10.15.3`。

### 例子

假设在我的一个项目中，我需要使用Node.js的版本8.9.4，因为这是项目依赖的版本。我会这样操作：

```bash
nvm install 8.9.4
nvm use 8.9.4
node -v
```

这样，我就可以在我的Windows机器上配置并使用特定版本的Node.js，确保我的开发环境与项目要求一致。

使用NVM for Windows管理Node.js的多个版本可以极大地提高开发的灵活性和效率，尤其是当你在处理需要不同Node.js版本的多个项目时。

如何在Windows上安装旧版本的node.js？

当我们希望列出一个 npm package 依赖的所有 Node.js 模块时，我们可以通过几种方法来实现。以下是逐步说明如何操作的详细步骤：

### 1. 使用 `npm list` 命令

`npm list` 命令可以列出当前项目中安装的所有npm模块及其依赖。这个命令默认列出本地安装的所有模块。例如：

```bash
npm list
```

这将会显示当前项目的依赖树。

#### 查看全局安装的模块

如果想要查看全局安装的模块，可以添加 `-g` 标志：

```bash
npm list -g
```

### 2. 查看特定深度的依赖

如果只对顶层依赖感兴趣，可以使用 `--depth` 标志来限制显示的层级。例如，查看顶层依赖：

```bash
npm list --depth=0
```

### 3. 使用 `npm ls` 搜索特定模块

如果您正在寻找特定的模块，可以使用 `npm ls` 命令加上模块名。例如，查找所有项目中的 `express` 模块：

```bash
npm ls express
```

### 4. 利用 `package.json` 和 `package-lock.json`

您还可以手动检查 `package.json` 和 `package-lock.json` 文件中列出的依赖。`package.json` 中的 `dependencies`、`devDependencies` 和 `peerDependencies` 部分列出了项目直接依赖的模块，而 `package-lock.json` 文件提供了一个完整的、生成的依赖树，包括每个包的具体版本和来源。

```json
{
  "dependencies": {
    "express": "^4.17.1"
  }
}
```

### 实际例子

假设我正在开发一个使用 Express 和 Mongoose 的 Node.js 应用。我可以使用上述方法来监控和验证我项目中的依赖。

1. **首先**，我会运行 `npm list` 来查看所有依赖和子依赖。
2. **其次**，为了确保我安装了正确版本的 Express，我可能会用 `npm ls express` 来检查。
3. **最后**，检查 `package.json` 和 `package-lock.json` 确认我的 `express` 依赖是否正确锁定版本。

这些工具和方法对于管理大型项目中的依赖关系至关重要，确保应用的稳定性和安全性。

在Node.js的环境中，`npm link`是一个非常实用的命令，它允许开发者在本地开发模块时，将其链接到正在开发的项目中，而不需要发布到npm仓库。如果需要列出所有通过`npm link`链接的Node.js模块，可以通过以下步骤进行操作：

### 步骤 1: 查看全局链接的模块

首先，可以使用`npm list`命令配合`-g`（全局标志）来查看全局安装的所有npm包，包括通过`npm link`创建的链接。

```bash
npm list -g --depth=0
```

此命令将列出全局安装的所有顶级npm包。那些通过`npm link`链接的模块通常会在输出中显示为链接路径，而不是版本号。

### 步骤 2: 确定链接的模块

在步骤1的输出中，通过`npm link`链接的模块会显示一个路径而非版本号。例如，如果你有一个名为`example-module`的模块被链接，它可能会显示如下：

```
/usr/local/lib
└── example-module -> /Users/your-username/path-to-module/example-module
```

这里的箭头指向表示这是一个链接的模块，后面的路径是该模块的源代码所在的位置。

### 步骤 3: 检查特定项目的链接模块

如果你想要查看某个特定项目里通过`npm link`链接的模块，可以在该项目的根目录下运行相似的命令：

```bash
npm list --depth=0
```

这将列出项目依赖的所有顶级模块。同样地，通过`npm link`链接的模块会显示为一个路径。

### 实际应用示例

假设我正在开发一个名为`data-parser`的Node.js模块，同时在另一个项目`app-project`中需要使用这个模块。在`data-parser`模块的目录下运行`npm link`来创建全局链接，然后在`app-project`的目录下运行`npm link data-parser`来链接到该模块。使用上述命令，我可以在全局和项目级别查看这些链接，确保我的链接设置正确。

这些步骤和命令帮助开发者管理和调试通过`npm link`创建的本地模块链接，确保模块的正确链接和功能性。

在Node.js环境中，我们经常会使用npm（Node Package Manager）来管理项目的依赖。要列出与特定npm链接相关的所有Node.js模块，可以通过几种方法来实现：

### 1. 使用`npm list`命令
这是最直接的方法，可以在项目根目录下运行以下命令来列出所有已安装的Node.js模块：

```bash
npm list
```

这会列出当前项目所有安装的npm包及其依赖。这个列表会以树状结构显示，其中顶级是项目直接依赖的包。

### 2. 查看`package.json`文件
每个Node.js项目都应该有一个`package.json`文件，其中列出了项目的所有直接依赖（`dependencies`）和开发时依赖（`devDependencies`）。通过查看这个文件，可以直接了解到项目所依赖的npm包：

```json
{
  "dependencies": {
    "express": "^4.17.1",
    "lodash": "^4.17.20"
  },
  "devDependencies": {
    "jest": "^26.4.2",
    "eslint": "^7.10.0"
  }
}
```

### 3. 使用`npm list -g`
如果你想要列出全局安装的所有Node.js模块，可以使用以下命令：

```bash
npm list -g
```

这个命令会列出在全局环境中安装的所有npm包。这对于调试或确认全局工具和库的版本尤为有用。

### 例子
假设你正在开发一个使用Express框架的Web应用，你可能需要查看所有与Express相关的依赖。你可以在项目的根目录下运行：

```bash
npm list | grep express
```

这会列出所有包含"express"关键词的模块及其依赖，帮助你快速定位和理解项目中使用的Express版本和相关库。

### 总结
列出Node.js项目中的npm模块可以通过多种方式来实现，常用的方法包括使用`npm list`命令、检查`package.json`文件以及使用`npm list -g`命令查看全局模块。这些方法可以帮助开发者快速了解项目依赖的状态和结构。

如何列出 npm 链接的所有 NodeJS 模块

在NPM中更新`devDependencies`是维护项目依赖关系的重要部分，确保开发工具和库是最新的可以帮助提高开发效率，减少潜在的安全风险。以下是更新`devDependencies`的步骤及相关操作示例：

### 1. 查看可更新的包
首先，你可以使用 `npm outdated` 命令来查看项目中哪些依赖包可以更新。这个命令会列出所有依赖，并且特别标记出那些已经有新版本的依赖。

例如：
```bash
npm outdated
```

这个命令的输出会包括当前版本、需要的版本，以及最新版本。关注列表中`devDependencies`部分的包。

### 2. 更新特定的devDependencies
如果你只想更新某一个特定的开发依赖，可以使用 `npm install` 命令，配合包名和想要更新到的版本号，或者使用 `@latest` 标签指定最新版本。

例如，假设你想更新 `webpack` 这个开发依赖到最新版本：
```bash
npm install webpack@latest --save-dev
```

这个命令不仅更新了`webpack`，还会在`package.json`文件的`devDependencies`部分保存这个更改。

### 3. 批量更新所有devDependencies
如果你需要更新所有的开发依赖到最新版本，可以使用一些第三方工具如 `npm-check-updates`。首先，安装这个工具：
```bash
npm install -g npm-check-updates
```

然后运行下面的命令来升级所有的`devDependencies`：
```bash
ncu -u --dep dev
```

这个命令会检查所有devDependencies，并更新`package.json`中相应的版本号到最新版本。

### 4. 确认更新并安装
更新`package.json`后，使用以下命令安装更新后的包：
```bash
npm install
```

这样会根据`package.json`中的定义安装所有依赖，包括新更新的`devDependencies`。

### 结论
更新`devDependencies`是一个需要细心处理的过程，尤其是在大型项目中。更新之后，建议进行全面的测试，确保新版本的开发依赖没有引入任何破坏性的改变。通过定期更新，可以确保项目利用最新的开发工具和库，从而保持项目的安全性和效率。

NPM 如何更新 devDependencies ？

PM2是一个流行的Node.js应用的进程管理器，它帮助管理和保持应用程序在线。PM2可以生成日志文件，这些文件记录了应用程序的运行状况和输出的详细信息，这对于调试和监控应用程序非常有用。

默认情况下，PM2将其日志文件存储在`~/.pm2/logs/`目录中。在这个目录下，每个由PM2管理的应用程序都会有自己的日志文件，通常会有一个stdout日志文件和一个stderr日志文件。例如，如果你的应用程序名为`app`，那么你会发现`app-out.log`用于标准输出和`app-error.log`用于错误输出。

此外，PM2还提供了一些命令行选项来查看和管理日志文件，例如`pm2 logs`命令可以实时查看所有管理下的应用日志，或者通过`pm2 logs [app_name]`来查看特定应用的日志。这些工具非常方便用户进行日常的日志检查和问题排查。

PM2 日志文件的默认位置在哪儿？

是的，Maven 和 npm 在很多方面都有相似之处，它们都是项目管理和依赖管理的工具，但它们服务于不同的编程语言社区。Maven 主要用于 Java 项目，而 npm 是 Node.js 的包管理器，用于管理 JavaScript 项目。

### 相似点：
1. **依赖管理**：Maven 和 npm 都允许开发者定义项目依赖。在 Maven 中，依赖是通过 `pom.xml` 文件定义的，而在 npm 中，则是通过 `package.json` 文件。
   
2. **项目构建**：它们都支持自动化构建项目。Maven 使用的是预定义的生命周期和插件来构建 Java 项目，而 npm 可以运行预定义的脚本来构建、测试和运行 JavaScript 项目。

3. **仓库和模块**：两者都使用中央仓库来存储和检索依赖。Maven 从 Maven Central 下载依赖，npm 从 npm registry 下载包。

4. **版本控制**：Maven 和 npm 都支持语义版本控制，帮助开发者管理依赖的版本。

### 差异点：
1. **语言支持**：如前所述，Maven 主要用于 Java，而 npm 用于 JavaScript。这意味着它们各自的生态系统和工具链都是为这些特定语言优化的。

2. **构建系统**：Maven 使用基于 XML 的配置文件（`pom.xml`），而 npm 使用 JSON 格式的 `package.json`。Maven 的构建生命周期包括清理、编译、测试、打包等阶段，而 npm 的脚本可以更加灵活地自定义。

3. **插件系统**：Maven 提供了丰富的插件生态系统，可以通过插件来扩展其功能。虽然 npm 也可以使用各种工具和库来扩展功能，但它本身更多关注于包管理而不是插件扩展。

### 实例应用：
在一个 Java 项目中，如果我们需要添加一个日志库，如 log4j，我们会在 Maven 的 `pom.xml` 文件中添加相应的依赖项。类似地，在一个 Node.js 项目中，如果需要添加 lodash 这样的实用工具库，我们会在 `package.json` 中添加 lodash 的依赖，并通过 npm 安装它。

总的来说，尽管 Maven 和 npm 在功能和目的上有很多相似之处，但它们各自支持的平台和细节实现有所不同。通过了解和比较这些工具，开发者可以更好地选择适合自己项目需求的工具。

Maven 与 npm 相似吗？

要将npm的配置恢复或重置为默认值，有几种方法可以做到。以下是详细步骤和示例：

### 方法1：使用命令行

1. **使用`npm config`命令**：
   你可以使用`npm config delete <key>`命令来删除特定的配置项，从而恢复到默认设置。例如，如果你更改了`registry`配置，可以这样删除它：

   ```bash
   npm config delete registry
   ```

   删除配置后，npm将自动回退到默认的配置值。

2. **重置所有配置**：
   如果你想重置所有的配置项到默认值，可以删除整个npm配置文件。npm配置文件通常位于用户的主目录下的`.npmrc`文件中。可以这样删除：

   ```bash
   rm ~/.npmrc
   ```

   这将删除所有的用户级npm配置。当你下次运行npm命令时，它将使用默认配置。

### 方法2：编辑配置文件

1. **手动编辑`.npmrc`文件**：
   打开你的`.npmrc`配置文件，这个文件通常位于你的用户主目录。你可以使用任何文本编辑器打开它，例如使用命令行的`nano`或`vim`：

   ```bash
   nano ~/.npmrc
   ```

2. **查找并修改或删除特定的配置项**：
   在`.npmrc`文件中，你可以看到类似这样的行：

   ```
   registry=https://my.custom.registry/
   ```

   要恢复到默认配置，可以删除这行或将其更改回默认的npm仓库URL：

   ```
   registry=https://registry.npmjs.org/
   ```

   保存并关闭文件后，配置更改即会生效。

### 方法3：使用图形界面工具

如果你使用的是某些集成开发环境(IDE)或其他工具，它们可能提供了图形界面来管理npm配置。这些工具通常会在设置或首选项菜单中提供npm配置选项，你可以通过界面来重置特定的设置或全部设置。

### 注意：

- 在进行任何更改之前，最好备份你的`.npmrc`文件，以便在需要时可以恢复旧的配置。
- 某些npm配置可能是由全局或系统级的`.npmrc`文件设置的，这些文件通常位于不同的位置，例如`/etc/npmrc`或npm安装目录下的`etc`文件夹。这些全局配置不应轻易更改，除非你确信需要这么做。

通过上述方法，你可以根据需要将npm配置恢复到默认值。如果有任何问题，npm的官方文档提供了详细的配置指南和默认配置的信息，这可以为你提供进一步的帮助。

如何将npm配置恢复/重置为默认值？

当您需要并行运行多个 npm 脚本时，可以使用几种不同的方法。这里我将介绍几种常见的方法：

### 1. 使用 npm 的 `&` 运算符
在 npm 脚本中，您可以使用 UNIX 风格的 `&` 来并行运行命令。例如，如果您有两个脚本 `script1` 和 `script2` 您可以在 `package.json` 的 `scripts` 部分这样写：

```json
"scripts": {
  "run-parallel": "npm run script1 & npm run script2"
}
```

执行 `npm run run-parallel` 将会并行启动 `script1` 和 `script2`。但是要注意，这种方式在 Windows 命令行工具中可能不会以预期的方式工作，因为 Windows 的命令行环境并不完全支持 `&` 运算符。

### 2. 使用 npm 的 `&&` 运算符（不是并行）
虽然 `&&` 运算符通常用于顺序执行多个 npm 脚本，但如果您将其与 `&` 结合使用，也可以实现并行执行。如：

```json
"scripts": {
  "run-parallel": "npm run script1 & npm run script2 && wait"
}
```

这样 `script1` 和 `script2` 将会并行运行，`wait` 命令会等待前面的后台进程完成。这种方法在某些 UNIX 系统中有效，但是并不是所有的环境都支持 `wait` 命令。

### 3. 使用 npm 包如 `npm-run-all` 或 `concurrently`
为了更好的跨平台支持，并且更好的控制并行运行的脚本，您可以使用如 `npm-run-all` 或 `concurrently` 这样的 npm 包。以下是 `npm-run-all` 的一个例子：

首先，您需要安装 `npm-run-all`：

```bash
npm install --save-dev npm-run-all
```

然后，您可以在 `package.json` 的 `scripts` 部分使用它：

```json
"scripts": {
  "script1": "echo 'Running script 1'",
  "script2": "echo 'Running script 2'",
  "run-parallel": "npm-run-all --parallel script1 script2"
}
```

当执行 `npm run run-parallel` 时，`script1` 和 `script2` 将会并行执行。

这些方法中，使用 `npm-run-all` 或 `concurrently` 是最推荐的，因为它们提供了最好的跨平台兼容性，并且能够更精细地管理命令的输出和错误处理。例如，如果一个脚本失败，`concurrently` 可以配置为停止所有其他脚本，而 `npm-run-all` 则有类似的选项来管理脚本执行。

如何并行运行多个 npm 脚本？

要清除 `node_modules` 文件夹中没有在 `package.json` 中定义的包，可以使用几种方法。以下是解决这个问题的两种常见方式：

### 使用 `npm prune` 命令

`npm` 提供了一个内置的命令 `prune`，它用于移除 `node_modules` 目录中未在 `package.json` 文件的 `dependencies` 或 `devDependencies` 中声明的包。要使用 `npm prune`，您只需要在项目的根目录下打开终端，并执行以下命令：

```bash
npm prune
```

这条命令会根据当前 `package.json` 文件中定义的依赖项，删除所有不匹配的包。

### 手动清理和重新安装

如果想确保 `node_modules` 文件夹完全反映 `package.json` 文件中指定的依赖关系，您可以先手动删除 `node_modules` 文件夹，然后运行 `npm install` 重新安装所有依赖。以下是这个方法的步骤：

1. 删除 `node_modules` 文件夹：

   ```bash
   rm -rf node_modules
   ```
2. 清理 `npm` 缓存(可选)：

   ```bash
   npm cache clean --force
   ```
3. 使用 `npm install` 重新安装依赖：

   ```bash
   npm install
   ```

这将创建一个新的 `node_modules` 文件夹，其中仅包含 `package.json` 文件中声明的依赖包。

### 实际例子

假设我之前为了测试某些功能，临时安装了一个名为 `example-package` 的包，但后来发现它并不适合我的项目需求，所以我没有将它加入到 `package.json` 中。现在我的 `node_modules` 文件夹里有很多这样的包，我想清理它们。我会这样做：

1. 打开终端并导航到我的项目目录。
2. 运行 `npm prune` 命令。
3. `npm` 会检查 `package.json` 并自动移除所有未列出的包，包括 `example-package`。

这样，`node_modules` 文件夹就只包含了真正需要的依赖，我的项目也就更加整洁、更容易维护。


I think you're looking for `npm prune`

> `npm prune [<name> [<name ...]]`
> 
> This command removes "extraneous" packages. If a package name is provided, then only packages matching one of the supplied names are removed.
> 
> Extraneous packages are packages that are not listed on the parent package's dependencies list.

See the docs: [https://docs.npmjs.com/cli/prune](https://docs.npmjs.com/cli/prune)

You could remove your node\_modules/ folder and then reinstall the dependencies from package.json.

    rm -rf node_modules/
    npm install
    

This would erase all installed packages in the current folder and only install the dependencies from package.json. If the dependencies have been previously installed npm will try to use the cached version, avoiding downloading the dependency a second time.

> Due to its folder nesting Windows can’t delete the folder as its name is too long. To solve this, install RimRaf:

    npm install rimraf -g
    
    rimraf node_modules

From version 6.5.0 `npm` supports the command `clean-install` (`ci`) to hard refresh all the packages.

Please, see the references:

*   `npm` 6.x: [npm-ci | npm Docs](https://docs.npmjs.com/cli/v6/commands/npm-ci).
*   `npm` 7.x: [npm-ci | npm Docs](https://docs.npmjs.com/cli/v7/commands/npm-ci).
*   [npm Blog Archive: Introducing `npm ci` for faster, more reliable builds](https://blog.npmjs.org/post/171556855892/introducing-npm-ci-for-faster-more-reliable).

simple just run

    rm -r node_modules
    

in fact, you can delete any folder with this.

like **rm -r AnyFolderWhichIsNotDeletableFromShiftDeleteOrDelete**.

just open the **gitbash** move to root of the folder and run this command

Hope this will help.

如何清理 node_modules 文件夹中没有在 package.json 中安装的依赖包？

要更新全局安装的npm工具，您可以执行以下步骤：

1. **打开终端或命令提示符**: 这是您将输入命令的地方。

2. **检查是否有更新的工具**: 使用如下命令可以查看全局安装的npm包：
   ```
   npm outdated -g --depth=0
   ```
   这将列出所有已经过时的全局npm包和它们的当前版本、需要更新的版本以及最新版本。

3. **更新特定的npm工具**: 如果您只想更新一个特定的工具，可以使用命令：
   ```
   npm update <工具名> -g
   ```
   其中`<工具名>`是您想要更新的工具的名称。

4. **一次性更新所有全局工具**: 如果您想要更新所有过时的工具，您可以使用命令：
   ```
   npm update -g
   ```
   这会更新所有全局安装的且有新版本可用的npm工具。

5. **强制更新**: 如果因为某些原因`npm update`命令没有更新到最新版本，您可以通过先卸载再安装的方式强制更新。例如：
   ```
   npm uninstall -g <工具名>
   npm install -g <工具名>@latest
   ```
   这样会确保您安装的是该工具的最新版本。

6. **确认更新**: 更新完成后，您可以确认工具是否更新到了最新版本：
   ```
   npm list -g <工具名>
   ```
   或者，如果您想查看所有全局安装的工具及其版本，可以运行：
   ```
   npm list -g --depth=0
   ```

### 示例

假设我们想更新全局安装的`create-react-app`工具。以下是更新流程的步骤：

1. 打开您的命令行工具。

2. 检查是否有可用的更新：
   ```
   npm outdated -g --depth=0
   ```
   这可能会告诉您`create-react-app`的当前版本和最新版本。

3. 更新`create-react-app`到最新版本：
   ```
   npm update create-react-app -g
   ```

4. 确认更新：
   ```
   npm list -g create-react-app
   ```

以上步骤将帮助您保持全局npm工具的最新状态。

Note: The question is specifically asking how to upgrade npm, not Node.js. If you want to update Node.js over a CLI on windows, I recommend running `winget upgrade -q NodeJS` or use [chocolatey](https://community.chocolatey.org/packages/nodejs-lts) for that.

What method should I choose to update NPM?
------------------------------------------

*   Node.js v16 or higher?
    *   `npm install -g npm`
*   Node.js v14 or below?
    *   Consider updating to latest LTS release of Node.js
    *   `npm-windows-upgrade`

### [Upgrade with npm-windows-upgrade](https://github.com/felixrieseberg/npm-windows-upgrade)

Run PowerShell as Administrator

    Set-ExecutionPolicy Unrestricted -Scope CurrentUser -Force
    npm install -g npm-windows-upgrade
    npm-windows-upgrade
    

Note: if you run the Node.js installer, it will replace the Node.js version.

*   Upgrades npm in-place, where Node.js installed it.
*   Does not modify the default path.
*   Does not change the default global package location.
*   Allows easy upgrades and downgrades and to install a specific version.
*   A list of versions matched between NPM and Node.js ([https://nodejs.org/en/download/releases/](https://nodejs.org/en/download/releases/)) - but you will need to download the _Node.js installer_ and run that to update Node.js ([https://nodejs.org/en/](https://nodejs.org/en/))

### Upgrade with npm

    npm install -g npm
    

Note: some users still report issues updating npm with npm, but I haven't had that experience with v16+.

[Download](https://nodejs.org/en/download) and run the latest MSI. The MSI will update your installed node and npm.

To update NPM, this worked for me:

*   Navigate in your shell to your node installation directory, eg `C:\Program Files (x86)\nodejs`
*   run `npm install npm` (no `-g` option)

Like some people, I _needed_ to combine multiple answers, and I also needed to set a proxy.

This _should_ work for anyone. I have zero desire to run an EXE file or MSI file .. uninstall/ reinstall, or manually delete files and folders. That is so 1999 :P

1.  Run this to update NPM:
    
    Run PowerShell as **administrator**
    
        npm i -g npm    // This works
        
    
    I am _not_ thinking this code actually upgrades your npm version below
    
        Set-ExecutionPolicy Unrestricted -Scope CurrentUser -Force
        npm install -g npm-windows-upgrade
        npm-windows-upgrade
        
        (courtesy of "Robert" answer)
        
    

**Run this to update Node.js:**

    wget https://nodejs.org/download/release/latest/win-x64/node.exe -OutFile 'C:\Program Files (x86)\nodejs\node.exe'    (courtesy of BrunoLM answer)
    

If you get \`wget : Could not find a part of the path .... "\*\*, see below ...scroll down. Reading Web Response... It's at least punching through the firewall /proxy (if you have one or have already ran the code get through ...

**_Otherwise_**

**You might need to set your proxy**

    npm config set proxy "http://proxy.yourcorp.com:811"    (yes, use quotes)
    

**2 possible errors**

1.  It cannot find path of the path solution **"where.exe node"** (courtesy of Lonnie Best Answer)
    
    E.g. if Node.js is NOT living in "Program Files (x86)" perhaps with where.exe, it is living in 'C:\\Program Files\\nodejs\\node.exe'.
    
        wget https://nodejs.org/download/release/latest/win-x64/node.exe -OutFile 'C:\Program Files\nodejs\node.exe'
        
    
2.  Now perhaps it tries to upgrade but you get _another_ error, _"node.exe is being used by another process."_
    
    *   Close /shutdown other consoles .. command prompts and PowerShell windows, etc. Even if you're using npm in a command prompt, close it.

npm -v (3.10.8)

node -v ( v6.6.0)

**DONE. I'm at the version that I _want_.**

You can update your npm to the latest stable version with the following command:

     npm install npm@latest -g
    

Use PowerShell to run it. This command doesn't need windows administrator privileges and you can verify the result with `npm -v`

如何在 Windows 系统上更新 npm ？

当然，`nvm`（Node Version Manager）是一个用于管理和切换不同Node.js版本的工具。它也允许用户为不同的Node.js版本安装与之兼容的`npm`版本。以下是如何使用`nvm`来更改`npm`版本的步骤：

1. **安装 nvm：**
   首先，您需要确保已经安装了`nvm`。可以通过运行以下命令在Linux或macOS上安装`nvm`：

   ```sh
   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
   ```

   或者，如果您使用的是Windows，则可以使用`nvm-windows`：

   ```sh
   nvm install-latest-npm
   ```

2. **列出可用的 Node.js 版本：**
   安装好`nvm`后，您可以查看所有可用的Node.js版本：

   ```sh
   nvm ls-remote
   ```

3. **安装 Node.js：**
   使用`nvm`安装一个特定版本的Node.js。`npm`会与该版本捆绑安装：

   ```sh
   nvm install 14.17.0
   ```

   这将安装Node.js 14.17.0版本和与之兼容的`npm`版本。

4. **切换 Node.js 版本：**
   安装多个版本的Node.js后，可以使用以下命令在它们之间切换：

   ```sh
   nvm use 14.17.0
   ```

   这将切换到Node.js 14.17.0版本和相应的`npm`版本。

5. **升级 npm：**
   如果你想要为当前使用的Node.js版本升级`npm`，可以运行：

   ```sh
   npm install -g npm@latest
   ```

   这将为当前选中的Node.js版本安装最新版本的`npm`。

6. **查看 npm 版本：**
   可以通过运行以下命令来验证`npm`的版本：

   ```sh
   npm --version
   ```

7. **为特定的 Node.js 版本安装特定的 npm 版本：**
   如果需要为特定的Node.js版本安装一个特定版本的`npm`，可以先切换到该Node.js版本，然后指定`npm`版本进行安装：

   ```sh
   nvm use 14.17.0
   npm install -g npm@6.14.13
   ```

   这样，您就可以为Node.js 14.17.0安装npm 6.14.13版本。

以上就是使用`nvm`管理和更改`npm`版本的基本步骤。这使得在不同的项目之间切换开发环境变得非常简单，因为每个项目可能需要不同的Node.js和`npm`版本。

As noted in [another answer](https://stackoverflow.com/a/47519162/56817), there is now a command for this:

> nvm now has a command to update npm. It's `nvm install-latest-npm` or `nvm install --latest-npm`.

`nvm install-latest-npm`: Attempt to upgrade to the latest working `npm` on the current Node.js version.

`nvm install --latest-npm`: After installing, attempt to upgrade to the latest working npm on the given Node.js version.

Below are previous revisions of the correct answer to this question.

For later versions of npm it is much simpler now. Just update the version that nvm installed, which lives in `~/.nvm/versions/node/[your-version]/lib/node_modules/npm`.

I installed Node.js 4.2.2, which comes with npm 2.14.7, but I want to use npm 3. So I did:

    cd ~/.nvm/versions/node/v4.2.2/lib
    npm install npm
    

Easy!

And yes, this should work for any module, not just npm, that you want to be "global" for a specific version of node.

* * *

In a newer version, `npm -g` is smart and installs modules into the path above instead of the system global path.

Use

    npm install npm@x.x.x -g
    npm install npm@5.4.0 -g

nvm doesn't handle npm.

So if you want to install Node.js 0.4.x (which many packages still depend on) and use NPM, you can still use npm 1.0.x.

Install Node.js 0.6.x (which comes with npm 1.1.x) and install nvm with npm:

    npm install nvm
    . ~/nvm/nvm.sh
    

Install Node.js 0.4.x with nvm:

    nvm install v0.4.12
    nvm use v0.4.12
    

Install npm using _install.sh_ (note the `-L` parameter to follow any redirects):

    curl -L https://npmjs.org/install.sh | sh
    

This will detect Node.js 0.4.12 and install npm 1.0.106 in your _~/nvm/v0.4.12/lib/node\_modules_ folder and create a symbolic link for nvm:

    ~/nvm/v0.4.12/bin/npm -> ../lib/node_modules/npm/bin/npm-cli.js
    

If you try to run npm, it will still give an error, but if you do `nvm use v0.4.12` again, it should now work.

nvm now has a command to update npm. It's `nvm install-latest-npm` or `npm install --latest-npm`.

I'm on Windows and I couldn't get any of this stuff to work. I kept getting errors about files being in the way. This worked though:

    cd %APPDATA%\nvm\v8.10.0           # or whatever version you're using
    mv npm npm-old
    mv npm.cmd npm-old.cmd
    cd node_modules\
    mv npm npm-old
    cd npm-old\bin
    node npm-cli.js i -g npm@latest
    
    cd %APPDATA%\nvm\v8.10.0 # or whatever version you're using
    rm npm-old
    rm npm-old.cmd
    cd node_modules\
    rm -rf npm-old
    

And boom, I'm back in business.

`nvm`（Node Version Manager）是一个用于管理和切换不同Node.js版本的工具。它也允许用户为不同的Node.js版本安装与之兼容的 `npm`版本。以下是如何使用 `nvm`来更改 `npm`版本的步骤： 

1. **安装 nvm：**
   首先，您需要确保已经安装了 `nvm`。可以通过运行以下命令在Linux或macOS上安装 `nvm`：

   ```sh
   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
   ```

   或者，如果您使用的是Windows，则可以使用 `nvm-windows`：

   ```sh
   nvm install-latest-npm
   ```
2. **列出可用的 Node.js 版本：**
   安装好 `nvm`后，您可以查看所有可用的Node.js版本：

   ```sh
   nvm ls-remote
   ```
3. **安装 Node.js：**
   使用 `nvm`安装一个特定版本的Node.js。`npm`会与该版本捆绑安装：

   ```sh
   nvm install 14.17.0
   ```

   这将安装Node.js 14.17.0版本和与之兼容的 `npm`版本。
4. **切换 Node.js 版本：**
   安装多个版本的Node.js后，可以使用以下命令在它们之间切换：

   ```sh
   nvm use 14.17.0
   ```

   这将切换到Node.js 14.17.0版本和相应的 `npm`版本。
5. **升级 npm：**
   如果你想要为当前使用的Node.js版本升级 `npm`，可以运行：

   ```sh
   npm install -g npm@latest
   ```

   这将为当前选中的Node.js版本安装最新版本的 `npm`。
6. **查看 npm 版本：**
   可以通过运行以下命令来验证 `npm`的版本：

   ```sh
   npm --version
   ```
7. **为特定的 Node.js 版本安装特定的 npm 版本：**
   如果需要为特定的Node.js版本安装一个特定版本的 `npm`，可以先切换到该Node.js版本，然后指定 `npm`版本进行安装：

   ```sh
   nvm use 14.17.0
   npm install -g npm@6.14.13
   ```

   这样，您就可以为Node.js 14.17.0安装npm 6.14.13版本。

以上就是使用 `nvm`管理和更改 `npm`版本的基本步骤。这使得在不同的项目之间切换开发环境变得非常简单，因为每个项目可能需要不同的Node.js和 `npm`版本。

如何使用 nvm 更改 npm 的版本？

`npm install`和`npm ci`是Node.js生态系统中常用的两个命令，它们都用于安装依赖项，但是它们的工作方式和用途略有不同：

1. **npm install**:
   - **用途**：`npm install`是最常用的命令之一，用于安装依赖项。它根据`package.json`文件中列出的依赖项来安装模块，并且可以更新`package-lock.json`文件。
   - **行为**：`npm install`会根据`package.json`或`npm-shrinkwrap.json`中定义的依赖版本范围来查找并安装最新版本的依赖。如果`package-lock.json`存在，它也会考虑这个文件，但是它允许根据`package.json`中指定的语义版本控制规则更新依赖项。
   - **例子**：如果你的`package.json`文件指定了某个包的版本为`^1.0.0`，这意味着运行`npm install`时可以安装这个包的任何`1.x.x`版本，只要这个版本是最新的并且满足`package.json`中的约束。

2. **npm ci**:
   - **用途**：`npm ci`（ci代表Continous Integration持续集成）主要用在自动化环境中，比如测试平台、持续集成和部署流程。这个命令需要在存在`package-lock.json`或`npm-shrinkwrap.json`文件的情况下运行。
   - **行为**：`npm ci`会忽略`package.json`中的依赖项版本，而是严格根据`package-lock.json`或`npm-shrinkwrap.json`文件来安装依赖项的特定版本。这确保了在不同环境和开发人员之间的一致性。
   - **速度**：`npm ci`通常比`npm install`更快，因为它跳过了某些面向用户的功能，如更新`package-lock.json`文件或安装新版本的包。
   - **例子**：如果你将项目的代码库和`package-lock.json`文件一起部署到持续集成服务器上，运行`npm ci`将确保服务器上安装的依赖项与你在本地开发环境中使用的完全相同。

总之，如果你希望在本地开发环境中安装或更新依赖项，通常会使用`npm install`。而如果你在自动化环境中，需要一个可重复的、确定的依赖项安装过程，就会使用`npm ci`。

From [the official documentation for npm ci](https://docs.npmjs.com/cli/ci):

> In short, the main differences between using npm install and npm ci are:
> 
> *   The project must have an existing package-lock.json or npm-shrinkwrap.json.
> *   If dependencies in the package lock do not match those in package.json, npm ci will exit with an error, instead of updating the package lock.
> *   npm ci can only install entire projects at a time: individual dependencies cannot be added with this command.
> *   If a node\_modules is already present, it will be automatically removed before npm ci begins its install.
> *   It will never write to package.json or any of the package-locks: installs are essentially frozen.

* * *

Essentially, **`npm install`** reads `package.json` to create a list of dependencies and uses `package-lock.json` to inform which versions of these dependencies to install. **If a dependency is not in `package-lock.json` it will be added by `npm install`**.

**`npm ci`** (also known as **C**lean **I**nstall) is meant to be used in automated environments — such as test platforms, continuous integration, and deployment — or, any situation where you want to make sure you're doing a clean install of your dependencies.

It installs dependencies directly from `package-lock.json` and uses `package.json` only to validate that there are no mismatched versions. **If any dependencies are missing or have incompatible versions, it will throw an error**.

Use `npm install` to add new dependencies, and to update dependencies on a project. Usually, you would use it during development after pulling changes that update the list of dependencies but it may be a good idea to use `npm ci` in this case.

Use `npm ci` if you need a deterministic, repeatable build. For example during continuous integration, automated jobs, etc. and when installing dependencies for the first time, instead of `npm install`.

[`npm install`](https://docs.npmjs.com/cli/install.html)
--------------------------------------------------------

*   Installs a package and all its dependencies.
*   Dependencies are driven by `npm-shrinkwrap.json` and `package-lock.json` (in that order).
*   **without arguments**: installs dependencies of a local module.
*   Can install global packages.
*   Will install any missing dependencies in `node_modules`.
*   It may write to `package.json` or `package-lock.json`.
    *   When used with an argument (`npm i packagename`) it may write to `package.json` to add or update the dependency.
    *   when used without arguments, (`npm i`) it may write to `package-lock.json` to lock down the version of some dependencies if they are not already in this file.

[`npm ci`](https://docs.npmjs.com/cli/ci)
-----------------------------------------

*   Requires at least npm [v5.7.1](https://github.com/npm/npm/releases/tag/v5.7.1).
*   Requires `package-lock.json` or `npm-shrinkwrap.json` to be present.
*   Throws an error if dependencies from these two files don't match `package.json`.
*   Removes `node_modules` and install _all dependencies_ at once.
*   It never writes to `package.json` or `package-lock.json`.

Algorithm
---------

While `npm ci` generates the entire dependency tree from `package-lock.json` or `npm-shrinkwrap.json`, `npm install` _updates the contents of `node_modules`_ using the following algorithm ([source](https://docs.npmjs.com/cli/install#algorithm)):

>     load the existing node_modules tree from disk
>     clone the tree
>     fetch the package.json and assorted metadata and add it to the clone
>     walk the clone and add any missing dependencies
>       dependencies will be added as close to the top as is possible
>       without breaking any other modules
>     compare the original tree with the cloned tree and make a list of
>     actions to take to convert one to the other
>     execute all of the actions, deepest first
>       kinds of actions are install, update, remove and move
>

`npm ci` will delete any existing `node_modules` folder and relies on the `package-lock.json` file to install the specific version of each package. It is significantly faster than npm install because it skips some features. Its clean state install is great for ci/cd pipelines and docker builds! You also use it to install everything all at once and not specific packages.

While everyone else has answered the technical differences none explain in what situations to use both.
-------------------------------------------------------------------------------------------------------

You should use them in different situations.

`npm install` is great for development and in the CI when you want to cache the `node_modules` directory. When to use this? You can do this if you are making a package for other people to use _(you do NOT include `node_modules` in such a release)_. Regarding the caching, be careful, if you plan to support different versions of `Node.js` remember that `node_modules` might have to be reinstalled due to differences between the `Node.js` runtime requirements. If you wish to stick to one version, stick to the latest `LTS`.

`npm ci` should be used when you are to test and release a production application (a final product, not to be used by other packages) since it is important that you have the installation be as deterministic as possible, this install will take longer but will ultimately make your application more reliable _(you do include `node_modules` in such a release)_. Stick with `LTS` version of `Node.js`.

`npm i` and `npm ci` both utilize the npm cache if it exists, this cache lives normally at `~/.npm`.

Also, `npm ci` respects the `package-lock.json` file. Unlike `npm install`, which rewrites the file and always installs new versions.

_Bonus: You could mix them depending on how complex you want to make it. On feature branches in `git` you could cache the `node_modules` to increase your teams productivity and on the merge request and master branches rely on `npm ci` for a deterministic outcome._

*   `npm ci` - install exactly what is listed in package-lock.json
*   `npm install` - without changing any versions in package.json, use package.json to write package-lock.json, then install exactly what is listed in package-lock.json
*   `npm update` - similar to `npm install` but will also install updates for "blurred version" stuff (e.g. `*`, `^1.2.3`)
*   `npx npm-check-updates -u; npm install` - Will try to update absolutely everything to the latest version. Be careful of breaking changes when using this one.

Or said a different way, `npm ci` changes 0 package files, `npm install` and `npm update` change 1 package file (package-lock.json), and `npx npm-check-updates -u; npm install` changes 2 package files (package.json and package-lock.json).

The documentation you linked had the summary:

> In short, the main differences between using npm install and npm ci are:
> 
> *   The project must have an existing package-lock.json or npm-shrinkwrap.json.
> *   If dependencies in the package lock do not match those in package.json, npm ci will exit with an error, instead of updating the package lock.
> *   npm ci can only install entire projects at a time: individual dependencies cannot be added with this command.
> *   If a node\_modules is already present, it will be automatically removed before npm ci begins its install.
> *   It will never write to package.json or any of the package-locks: installs are essentially frozen.

Npm install 和 npm ci 之间有什么区别？

在`package.json`中，您通常不会直接设置环境变量，因为这个文件主要是用来定义项目的依赖、脚本和配置信息。然而，您可以在`package.json`的`scripts`部分定义脚本命令，在执行这些命令时设置环境变量。

例如，如果您使用的是Unix-like系统（如Linux或MacOS），可以使用`export`命令设置环境变量，然后执行其他命令。如果您在Windows上，则可能需要使用`set`命令，或者使用跨平台的解决方案，比如`cross-env`。

下面是一个如何在`scripts`部分设置环境变量的例子：

```json
{
  "name": "your-package",
  "version": "1.0.0",
  "scripts": {
    "start": "export NODE_ENV=production && node app.js",
    "start:windows": "set NODE_ENV=production && node app.js"
  }
}
```

在上面的例子中，我们在`start`脚本中设置了`NODE_ENV`环境变量为`production`，然后执行了`node app.js`。

使用`cross-env`，您可以写一个跨平台的脚本命令：

```json
{
  "name": "your-package",
  "version": "1.0.0",
  "scripts": {
    "start": "cross-env NODE_ENV=production node app.js"
  },
  "devDependencies": {
    "cross-env": "^7.0.3"
  }
}
```

在这个例子中，不管您在什么操作系统上，`start`脚本都会设置`NODE_ENV`环境变量为`production`，然后运行`node app.js`。注意，您需要先安装`cross-env`作为开发依赖（使用命令`npm install --save-dev cross-env`）。

这种方式是非常灵活的，允许您在不同的环境（开发、测试、生产等）中运行不同的命令。记住，这里设置的环境变量只会在脚本运行时存在，脚本执行完毕后，这些环境变量不会影响到其他的shell进程。

Set the environment variable in the script command:

    ...
    "scripts": {
      "start": "node app.js",
      "test": "NODE_ENV=test mocha --reporter spec"
    },
    ...
    

Then use `process.env.NODE_ENV` in your app.

Note: This is for _Mac & Linux only_. For Windows refer to the comments.

Just use NPM package [cross-env](https://www.npmjs.com/package/cross-env). Super easy. Works on Windows, Linux, and all environments. Notice that you don't use && to move to the next task. You just set the env and then start the next task. Credit to [@mikekidder](https://stackoverflow.com/users/2130585/mikekidder) for the suggestion in [one of the comments](https://stackoverflow.com/questions/25112510/how-to-set-environment-variables-from-within-package-json-node-js#comment57929242_27090755) here.

From documentation:

    {
      "scripts": {
        "build": "cross-env NODE_ENV=production OTHERFLAG=myValue webpack --config build/webpack.config.js"
      }
    }
    

Notice that if you want to set multiple global vars, you just state them in succession, followed by your command to be executed.

Ultimately, the command that is executed (using spawn) is:

    webpack --config build/webpack.config.js
    

The `NODE_ENV` environment variable will be set by cross-env

Because I often find myself working with multiple environment variables, I find it useful to keep them in a separate `.env` file (make sure to ignore this from your source control). Then (in Linux) prepend `export $(cat .env | xargs) &&` in your script command before starting your app.

Example `.env` file:

    VAR_A=Hello World
    VAR_B=format the .env file like this with new vars separated by a line break
    

Example `index.js`:

    console.log('Test', process.env.VAR_A, process.env.VAR_B);
    

Example `package.json`:

    {
      ...
      "scripts": {
        "start": "node index.js",
    
        "env-linux": "export $(cat .env | xargs) && env",
        "start-linux": "export $(cat .env | xargs) && npm start",
    
        "env-windows": "(for /F \"tokens=*\" %i in (.env) do set %i)",
        "start-windows": "(for /F \"tokens=*\" %i in (.env) do set %i) && npm start",
    
      }
      ...
    }
    

Unfortunately I can't seem to set the environment variables by calling a script from a script -- like `"start-windows": "npm run env-windows && npm start"` -- so there is some redundancy in the scripts.

For a test you can see the env variables by running `npm run env-linux` or `npm run env-windows`, and test that they make it into your app by running `npm run start-linux` or `npm run start-windows`.

I just wanted to add my two cents here for future Node-explorers. On my Ubuntu 14.04 the `NODE_ENV=test` didn't work, I had to use `export NODE_ENV=test` after which `NODE_ENV=test` started working too, weird.

On Windows as have been said you have to use `set NODE_ENV=test` but for a cross-platform solution the cross-env library didn't seem to do the trick and do you really need a library to do this:

    export NODE_ENV=test || set NODE_ENV=test&& yadda yadda
    

The vertical bars are needed as otherwise Windows would crash on the unrecognized `export NODE_ENV` command. I don't know about the trailing space, but just to be sure I removed them too.

Try this on Windows by replacing `YOURENV`:

      {
        ...
         "scripts": {
           "help": "set NODE_ENV=YOURENV && tagove help",
           "start": "set NODE_ENV=YOURENV && tagove start"
         }
        ...
      }

NPM相关问题