pnpm（Performant npm）是一个快速的，节省磁盘空间的包管理工具，用于 JavaScript 和 Node.js 生态系统。它是 npm 和 Yarn 的一个替代品，旨在提供更快、更高效的依赖管理解决方案。pnpm 主要通过使用硬链接和符号链接的方式来存储一个版本的包的单一副本，从而减少磁盘空间的使用和加速安装过程。

PNPM

在使用`pnpm`作为包管理工具时，如果你有一个工作区（workspace）项目，可能需要对子包（packages）进行构建，并且这些包之间存在依赖关系。为了控制它们的构建顺序，让依赖项先被构建，你可以使用`pnpm`的几种策略。

### 1. 使用`pnpm -r`或`--recursive`

`pnpm`支持递归地在工作区中运行命令，它会自动识别包之间的依赖关系并按照正确的顺序运行。

```sh
pnpm -r --filter <filter-pattern> run <command>
```

例如，如果你想要构建所有的包，可以使用：

```sh
pnpm -r run build
```

### 2. 使用`--sort`标志

在运行`pnpm -r`时，可以添加`--sort`标志，这样`pnpm`将按照拓扑顺序执行命令，确保依赖先于依赖它们的包被处理。

```sh
pnpm -r --sort run build
```

### 3. 使用`pnpm`的`pnpm-workspace.yaml`文件

通过在`pnpm-workspace.yaml`文件中声明包的顺序，`pnpm`会在执行命令时考虑这个顺序。

```yaml
packages:
  - 'packages/utils'
  - 'packages/core'
  - 'packages/app'
```

`pnpm`会首先处理`packages/utils`，然后是`packages/core`，最后是`packages/app`。

### 4. 使用`pnpm`的过滤标志

`pnpm`支持使用过滤标志来限制命令运行的包的范围。

```sh
pnpm -r --filter "<package-name>" run build
```

你可以指定多个过滤条件来控制执行顺序。

### 5. 编写自定义脚本

如果你有特别复杂的构建需求，可以编写自定义的脚本来控制构建过程。例如，你可以使用Node.js脚本来分析`package.json`文件中的依赖，并按照你的特定需求执行构建任务。

```javascript
const { execSync } = require('child_process');
const { getWorkspaces } = require('some-workspaces-tool');

const buildPackage = (packageName) => {
  console.log(`Building ${packageName}...`);
  execSync(`pnpm run build`, { stdio: 'inherit', cwd: `packages/${packageName}` });
};

const workspaces = getWorkspaces();

// 自定义逻辑来排序和构建包
workspaces.sort(customSortFunction).forEach((workspace) => {
  buildPackage(workspace.name);
});
```

### 示例：

假设你有一个名为`@company/core`的包，它依赖于`@company/utils`。你希望在构建`@company/core`之前构建`@company/utils`。

你可以在`pnpm-workspace.yaml`中像这样指定包的顺序：

```yaml
packages:
  - 'packages/utils'
  - 'packages/core'
```

然后运行以下命令确保按照正确的顺序进行构建：

```sh
pnpm -r --sort run build
```

这会首先构建`utils`包，然后是`core`包。

使用`pnpm`的这些工具和策略，你可以有效地管理你的工作区项目的构建顺序，确保构建过程的正确性和效率。

如何控制 pnpm workspace 的构建顺序？

在使用 `pnpm` 执行命令时，如果您需要向脚本或命令传递任意参数，通常可以在命令后直接添加这些参数。但是，如果需要将参数传递给通过 `pnpm` 运行的npm脚本，则需要在参数前加上 `--` 来确保参数正确传递。

例如，如果您有一个名为 `start` 的npm脚本，您想传递一些任意参数给它，您可以这样做：

```sh
pnpm start -- --user=yourname --port=8080
```

在这个例子中，`--user=yourname` 和 `--port=8080` 是将要传递给 `start` 脚本的参数。`--` 确保 `pnpm` 会把后面的参数原封不动地传递给 `start`，而不是被 `pnpm` 本身消费。

另一个例子，如果你要使用 `pnpm exec` 命令执行一个工具，并且需要传递参数给那个工具，你通常不需要 `--`。例如：

```sh
pnpm exec some-tool --option=value
```

在这种情况下，`--option=value` 是直接传递给 `some-tool` 的参数。

请注意，pnpm的行为可能会与npm和yarn略有不同，但它们都支持使用 `--` 分隔符来传递额外的参数。

I am not sure why it throws an error. Sounds like a bug. However, this will work:

    pnpm run build --foo=bar
    

But it will not create the `npm_config_foo` env variable. It will just append the option to the executed script. So if your build script is `webpack`, then pnpm will run:

    webpack --foo=bar
    

So, it is basically like running `npm run build -- --foo=bar`. Or like running `yarn build --foo=bar`

You can read about this also in the pnpm docs: [https://pnpm.io/cli/run#options](https://pnpm.io/cli/run#options)

Pnpm 执行脚本时如何传递参数?

当您使用 `pnpm` 来安装全局包时，默认情况下，它会将包安装到一个特定的全局目录中。但是，如果需要更改全局包的安装位置，可以通过设置环境变量来实现。

对于 `pnpm` 而言，更改全局依赖包位置的方法如下：

1. **设置环境变量**：您需要设置 `PNPM_HOME` 环境变量，来指定全局依赖包的存储位置。同时，确保将 `${PNPM_HOME}/bin` 目录添加到您的 `PATH` 环境变量中，以便可以从任何地方运行这些全局安装的包。

2. **更新配置文件**：如果您不想每次打开新的终端或会话都设置一次环境变量，可以选择将这些环境变量添加到您的 shell 配置文件中（如 `.bashrc`, `.bash_profile`, `.zshrc` 等），这样它们将自动加载。

下面是在 Unix-like 系统（如 Linux 或 macOS）上设置这些环境变量的步骤：

```sh
# 设置 PNPM_HOME 环境变量来指定全局依赖包的新位置
export PNPM_HOME="/path/to/your/global/pnpm/location"

# 将 PNPM_HOME/bin 添加到 PATH 环境变量中
export PATH="$PNPM_HOME/bin:$PATH"

# 将这些行添加到您的 shell 配置文件中，比如 .bashrc 或 .zshrc，
# 以确保每次新的终端会话都会设置这些变量。
echo 'export PNPM_HOME="/path/to/your/global/pnpm/location"' >> ~/.bashrc
echo 'export PATH="$PNPM_HOME/bin:$PATH"' >> ~/.bashrc
```

如果您使用的是 Windows 系统，则可以在“系统属性”中的“环境变量”设置或通过命令行（例如，使用 PowerShell）来设置环境变量：

```powershell
# 设置 PNPM_HOME 环境变量来指定全局依赖包的新位置
$env:PNPM_HOME="C:\path\to\your\global\pnpm\location"

# 将 PNPM_HOME\bin 添加到 PATH 现有的环境变量中
$env:PATH="$env:PNPM_HOME\bin;$env:PATH"

# 永久设置环境变量，您需要使用 Set-ItemProperty
Set-ItemProperty -Path 'HKCU:\Environment' -Name 'PNPM_HOME' -Value 'C:\path\to\your\global\pnpm\location'
[System.Environment]::SetEnvironmentVariable('PATH', "$env:PNPM_HOME\bin;$env:PATH", [System.EnvironmentVariableTarget]::User)
```

在设置了这些环境变量后，您在使用 `pnpm install -g <package>` 命令安装任何全局包时，pnpm 会将它们安装到您指定的新位置。记得替换上述命令中的 `/path/to/your/global/pnpm/location` 和 `C:\path\to\your\global\pnpm\location` 为您希望全局包安装的实际路径。

For pnpm v6, use `global-dir` instead of `pnpm-prefix`:

    pnpm config set global-dir <dir>
    

Although `<dir>` can be arbitrary, to keep the original directory structure, it should be `<your npm prefix>/pnpm-global`.

From [changelog](https://github.com/pnpm/pnpm/blob/main/packages/pnpm/CHANGELOG.md#600):

> The `pnpm-prefix` setting is removed. Use `global-dir` to specify a custom location for the globally installed packages.

Set the `pnpm-prefix` config with the desired location

    pnpm config set pnpm-prefix <dir>

如何更改 pnpm 安装全局依赖包的存储位置？

迁移项目从npm到pnpm是一个可以提高包管理效率和节省磁盘空间的好方法。下面是一个详细的步骤指南：

### 1. 安装pnpm
首先，你需要在你的机器上安装pnpm。可以通过以下命令安装：

```bash
npm install -g pnpm
```

### 2. 准备迁移
在迁移之前，应该确保当前项目在npm下是处于工作状态的，这包括运行测试和确保所有依赖都是最新的。这样可以比较迁移前后的行为，确保迁移没有引入问题。

### 3. 删除node_modules和package-lock.json
pnpm使用不同的方式来安装和链接依赖，所以需要删除现有的`node_modules`文件夹以及`package-lock.json`或`npm-shrinkwrap.json`文件（如果存在的话）：

```bash
rm -rf node_modules package-lock.json
```

### 4. 使用pnpm安装依赖
现在你可以使用pnpm来安装你的项目依赖了。在你的项目根目录下运行：

```bash
pnpm install
```

这将会安装所有在`package.json`中声明的依赖，并创建一个`pnpm-lock.yaml`文件，类似npm的`package-lock.json`，但是是为了pnpm定制的。

### 5. 测试项目
安装完成后，运行项目的测试和构建脚本，确保一切工作如预期。你可以运行：

```bash
pnpm run test
pnpm run build
# 或者其他相应的脚本
```

如果遇到任何与依赖相关的问题，检查并更新`package.json`中的依赖声明，并确保它们与`pnpm-lock.yaml`匹配。

### 6. 更新CI/CD脚本
如果你的项目使用了持续集成/持续部署(CI/CD)，确保更新相关脚本以使用pnpm命令替代npm命令。

例如，你可能需要更新`.travis.yml`、`Jenkinsfile`、`GitLab-CI.yml`等配置文件。

### 7. 提交更改
提交这些更改到版本控制系统：

```bash
git add pnpm-lock.yaml
git commit -m "Migrate from npm to pnpm"
```

确保不要提交`node_modules`文件夹，通常这个文件夹应该在`.gitignore`中排除。

### 8. 通知团队成员
如果你是在团队中工作，确保通知所有成员他们需要切换到pnpm。你可以提供pnpm安装步骤和迁移后可能遇到的常见问题。

### 9. 监控生产环境
如果迁移后的项目将要部署到生产环境，密切监控应用程序以确保没有因为迁移而引起的问题。如果有问题，根据日志和指标迅速定位问题源头并修复。

以上是将项目从npm迁移到pnpm的一个基本指南。实际过程可能会根据项目的具体情况（如依赖的复杂性，自动化脚本的使用等）而有所不同。

Finally, I have made a backup of `node_modules` and rebuilt it from scratch with `pnpm` and added `concat` to have only one JavaScript source and applied `Google-compiler` to it.

The only difficulty was about `bootstrap` because it has changed a lot in two years. We need to keep the old look of it, so the command I used is `pnpm install bootstrap@3.3.7`.

After completion, the look and feel was identical but `node_modules` has grew from 8 MB to 12 MB...

You can `pnpm import` which takes your `package-lock.json` or `yarn.lock` and generates pnpm's lock file `pnpm-lock.yaml`. After that, you can `pnpm install` to install the dependencies of the project.

[documentation](https://pnpm.io/cli/import)

如何将项目从 npm 迁移到 pnpm ？

`pnpm install` 和 `pnpm add` 是 `pnpm` 包管理器中的两个命令，它们在某些情况下功能相似，但在其它情况下则有明显的不同：

1. **pnpm install:**
   - 这个命令在没有参数的情况下，通常用于安装或更新`package.json`中列出的所有依赖。
   - 当你在项目初次创建时或者克隆他人的项目后，可以运行`pnpm install`来安装所有必要的依赖项。
   - `pnpm install`还用于在全局安装软件包时添加`-g`标志。
   - 如果你之前安装过依赖，`pnpm install`还会更新依赖并且保持与`pnpm-lock.yaml`文件的一致性。
   - 这个命令不会修改`package.json`文件，除非你结合使用一些参数，例如`pnpm install <package-name>`。

2. **pnpm add:**
   - `pnpm add`用来添加一个或多个新的依赖到项目中。
   - 运行`pnpm add <package-name>`会将最新版本的包添加到`package.json`的依赖列表中，并且安装该依赖。
   - 可以用`pnpm add <package-name>@<version>`来指定安装特定版本的包。
   - 类似地，可以通过加`-D`或`--save-dev`来将包添加为开发依赖。
   - `pnpm add`还可以用于全局安装软件包，通过添加`-g`标志。
   - 总结来说，`pnpm add`是用来添加新依赖的，并且会修改`package.json`和`pnpm-lock.yaml`文件。

### 示例：

假设我们有一个新的项目，需要添加`react`库：

- 使用`pnpm add react`会在项目的`package.json`中添加`react`作为依赖，并且安装它。
- 如果我们已经有了`package.json`并且列出了所需的依赖，那么使用`pnpm install`会根据这个文件安装所有列出的依赖。

总的来说，`pnpm add`用于添加新的依赖，而`pnpm install`通常用于安装或更新已有的依赖。在实践中，`pnpm add`命令通常在开发过程中使用，当你需要添加新库到你的项目中；而`pnpm install`则在项目初次设置或者当你需要根据版本锁文件来同步依赖时使用。

There is not much difference between them. In most cases they are interchangeable:

`pnpm install <args?>`: without `args` it will scan and install all the modules listed in `pnpm-lock.yaml`, in case of `args` it works as `pnpm add`

`pnpm add <args>`: It will install one more package.

if choose yes i will use `pnpm add` because it is new modern syntax that supports all package managers (`npm add`, `yarn add`)

Basically as per their docs:

* * *

We need to use _**`pnpm add`**_ when we want to add a new dependency to our project

* * *

We will be needing to use _**`pnpm install`**_ when we have an existing project with the lockfile and we want to install all dependencies from the lockfile.

* * *

For more information please refer to the official docs:

[PNPM Add Docs](https://pnpm.io/cli/add)  
[PNPM Install Docs](https://pnpm.io/cli/install)

**pnpm add** : Installs **a package** and any packages that it depends on.  
**pnpm install** : is used to install all dependencies for a project.

[https://pnpm.io/cli/install](https://pnpm.io/cli/install)  
[https://pnpm.io/cli/add](https://pnpm.io/cli/add)

“pnpm install”和“pnpm add”有什么不同？

要将某个依赖项添加到`pnpm`工作区，你需要遵循以下步骤：

1. **定位工作区的根目录**：
   `pnpm`工作区通常在一个包含`pnpm-workspace.yaml`文件的目录中定义。你需要先定位到这个根目录。

2. **选择要添加依赖的特定包**：
   工作区可能包含多个子项目或包，你需要确定要将依赖添加到哪个子项目中。

3. **使用`pnpm`添加依赖**：
   执行命令`pnpm add`来添加依赖项。如果你想要添加的是一个生产依赖项，你可以直接使用`pnpm add <依赖项名称>`；如果是开发依赖项，则使用`pnpm add <依赖项名称> --save-dev`。

以下是一些具体的例子：

- **为指定包添加生产依赖**：
  ```sh
  pnpm add lodash --filter <包名>
  ```
  这里`--filter <包名>`选项指定了将依赖项添加到哪个包中。如果你的工作区包名为`app`，你可以执行：
  ```sh
  pnpm add lodash --filter app
  ```

- **为指定包添加开发依赖**：
  ```sh
  pnpm add typescript --save-dev --filter <包名>
  ```
  如果你的包名为`app`，并且你想要添加TypeScript作为开发依赖项，你可以执行：
  ```sh
  pnpm add typescript --save-dev --filter app
  ```

- **为所有包添加依赖**：
  如果你想要将依赖项添加到工作区中的所有包，你可以省略`--filter`选项或使用通配符：
  ```sh
  pnpm add axios --filter '*'
  ```

请记住，使用`pnpm`时，当你在工作区的根目录中运行`pnpm add`命令并使用`--filter`选项时，依赖关系不仅会被添加到指定的包中，还会在工作区的`pnpm-lock.yaml`文件中锁定版本，确保工作区中的所有包都使用相同版本的依赖项。

So I found an answer and is using the `--filter` option.

i.e.

    # Using the exact package name
    pnpm add <package_to_add> --filter <workspace_name>
    # Or using a pattern
    pnpm add <package_to_add> --filter <prefix>/*
    

Same for run, etc...

如何将依赖项添加到 PNPM workspace？

`pnpm` 是一种包管理工具，与 `npm` 和 `yarn` 类似，但是它有自己独特的方式来管理包的存储。当你想要从本地存储中删除某个包，或者你想要强制重新下载某个包时，可以按照下面的步骤操作：

### 删除本地存储中的某个包

如果你需要从 `pnpm` 的全局存储中删除特定的包，可以使用 `pnpm store prune` 命令。这个命令会删除所有不被项目中的 `package.json` 文件依赖的包。

但是，如果你想要删除特定的包，可以手动去到 `pnpm` 的存储目录中删除对应的内容。`pnpm` 的存储目录通常在 `~/.pnpm-store`。

例如，要删除本地存储中的 `lodash` 包，你可以：

1. 找到 `lodash` 包在本地存储中的位置。
2. 直接删除该位置的相关文件和文件夹。

请注意，直接操作文件系统可能会导致 `pnpm` 的状态不一致，因此，请谨慎操作。

### 强制重新下载某个包

如果你想要强制重新下载某个包（也就是说，使 `pnpm` 忽略现有的缓存），你可以使用 `pnpm install` 命令配合 `--force` 参数。

例如，如果你想要重新下载 `express` 包，可以运行以下命令：

```sh
pnpm install express --force
```

这个命令会告诉 `pnpm` 忽略本地存储中的缓存，而是去远程仓库下载最新的 `express` 包。

再举一个实际的场景，假设你在开发一个项目，发现一个依赖的包存在问题，你可能需要删除它从而确保下次运行 `pnpm install` 时可以下载新的副本。在这种情况下，除了使用 `--force` 参数，你还可以先用 `pnpm remove` 删除该依赖，然后再次添加它：

```sh
# 删除依赖
pnpm remove lodash

# 重新添加依赖，这会下载最新的版本
pnpm add lodash
```

这样做也会导致 `pnpm` 从远程仓库下载 `lodash` 包的最新版本。

### 结论

要从 `pnpm` 的本地存储中删除包或强制重新下载，你可以使用 `pnpm store prune` 清理未使用的包，直接删除存储中的文件和文件夹，或者通过安装命令结合 `--force` 参数来忽略缓存。在实际操作中，都需要小心谨慎，确保不会影响到其他依赖或项目的正常运作。

{ My answer will cover pnpm `v2.16.2` }

Short answer: run `pnpm install --force`. (`pnpm update` might work as well)

Long answer. When you just run `pnpm install`, pnpm compares the wanted shrinkwrap file (`project/shrinkwrap.yaml`) to the current one (`project/node_modules/.shrinkwrap.yaml`). They equal in your case, so `node_modules` is not touched.

When `--force` is used, packages are reverified and relinked from the store. Reverification means that its integrity is checked. You removed a file from `jquery`, so verification will fail and the package will be reunpacked to the store and relinked to `node_modules`.

Alternatively, you could remove your project's `node_modules` and run `pnpm install`. That would also check the integrity of `jquery` before linking it to the store.

* * *

That being said, I think `pnpm install jquery` should also probably verify the integrity of jquery. We'll create an issue for this in the pnpm repo.

And maybe we can add some additional commands for reverifying every package in `node_modules` and re-unpacking all modified dependencies.

A related command currently available is [pnpm store status](https://pnpm.js.org/docs/en/pnpm-store.html#pnpm-store-status) which prints a list of mutated packages

如何从 pnpm 存储中删除某个依赖包，或者强制重新下载依赖包？

首先，`pnpm` 是一个快速、高效的包管理工具，它通过硬链接和符号链接的方式来节省磁盘空间，并且保证了不同项目间的依赖隔离。要确定 `pnpm` 的全局依赖库文件目录，我们可以使用 `pnpm` 命令本身来查询。  

可以通过以下命令获取 `pnpm` 的全局存储位置：

```sh
pnpm config get store-dir
```

执行这个命令后，`pnpm` 将会打印出用来存储全局依赖的文件目录路径。

举个例子，如果我在我的开发环境中运行这个命令，可能会得到类似这样的输出：

```plaintext
/home/username/.pnpm-store
```

这表明 `pnpm` 的全局依赖被存储在我的用户目录下的 `.pnpm-store` 文件夹中。

此外，了解 `pnpm` 的其他配置信息也是有用的。如果你想查看所有的 `pnpm` 配置，可以运行：

```sh
pnpm config list
```

这将列出所有的 `pnpm` 配置项，包括全局存储目录、当前的注册表以及其他相关的配置。

在实际的工作流中，知道如何查找全局存储目录可以帮助我们进行一些高级的操作，比如手动清理缓存或者调整存储位置来适用于特定的项目结构或者团队的工作流。

Nowadays you can do

    pnpm store path
    

which, according to pnpm's documentation:

> Returns the path to the active store directory.

The default locations of the store are:

*   If the `$XDG_DATA_HOME` env variable is set, then `$XDG_DATA_HOME/pnpm/store`
*   On Windows: `~/AppData/Local/pnpm/store`
*   On macOS: `~/Library/pnpm/store`
*   On Linux: `~/.local/share/pnpm/store`

Related docs: [https://pnpm.io/npmrc#store-dir](https://pnpm.io/npmrc#store-dir)

Seems like as of v3.0.1, you cannot get it. pnpm should probably update `pnpm get store` so that it returns the default location.

As of v3, the pnpm store is located at `~/.pnpm-store` by default.

You could also open the file `node_modules/.modules.yaml` in your project. It will contain a field called "store" with the location of the store that was used to hardlink packages to your project.

Update 2022:
============

As of v7, refer to @renardesque's or @nouvist's answer's below.

previously, pnpm store is located on user home folder.

    Linux   : ~/.pnpm-store
    Windows : C:\Users\YOUR_NAME\.pnpm-store
    macOS   : ~/.pnpm-store
    

but from now on ([`v7.0.0`](https://github.com/pnpm/pnpm/releases/tag/v7.0.0)), pnpm store is located on different folder. it will located on `$XDG_DATA_HOME` on Linux, and `%LOCALAPPDATA%` on Windows. take a look to [this issue](https://github.com/pnpm/pnpm/issues/2574).

    Linux   : ~/.local/share/pnpm/store (default)
    Windows : C:\Users\YOUR_NAME\AppData\Local\pnpm\store
    macOS   : ~/Library/pnpm/store
    

or, you can check where is located with [`pnpm store path`](https://pnpm.io/cli/store#path) command

**Possible locaiton:**

*   `~/.pnpm-store`  
    If project is on the **same** partition as _user home_.
*   `$partition_root/.pnpm-store`  
    If project is on **different** partition as _user home_.

**Why not just use** `~/.pnpm-store`:

*   On linux/mac, pnpm use hard link to reuse file.
*   And hard link, can be created only on the same partition.

Content-addressable store is at: C:\\Users\\username\\AppData\\Local\\pnpm\\store\\v3

Virtual store is at: node\_modules/.pnpm

如何获取 pnpm 的存储目录？

在面对需要切换不同版本的 PNPM 时，可以使用一些有效的工具和策略来管理这一过程。我将简要介绍几种常用的方法来实现这一目标，并且举例说明。

### 1. 使用 NVM（Node Version Manager）

NVM 是一个流行的 Node.js 版本管理工具，它也可以间接帮助管理不同版本的 PNPM，因为 PNPM 的运行依赖于 Node.js 的版本。使用 NVM 可以轻松切换 Node.js 版本，从而间接切换或重新安装不同版本的 PNPM。

**安装 NVM:**

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

**使用 NVM 安装并使用特定版本的 Node.js:**

```bash
nvm install 14
nvm use 14
```

**在该 Node.js 版本下安装 PNPM:**

```bash
npm install -g pnpm
```

### 2. 使用 PNPM 的自带版本管理功能

从 PNPM 6.10.0 版本开始，PNPM 支持了内置的版本管理功能，允许用户方便地切换不同版本的 PNPM。使用 `pnpm env` 命令可以管理不同的 Node.js 和 PNPM 环境。

**列出所有可用的 PNPM 版本:**

```bash
pnpm env list --available
```

**使用特定版本的 PNPM:**

```bash
pnpm env use --pnpm <version>
```

### 3. 使用 Volta

Volta 是另一个现代的工具，专门设计用于管理 JavaScript 命令行工具和库的版本，包括 Node.js 和包管理器如 PNPM。

**安装 Volta:**

```bash
curl https://get.volta.sh | bash
```

**使用 Volta 安装并使用特定版本的 PNPM:**

```bash
volta install pnpm@6.14.2
```

### 例子

假设我们正在一个项目中使用 PNPM 6.14.2 版本，突然需要切换到 5.18.9 版本来测试一些向下兼容性问题。我们可以使用 Volta 来实现快速切换：

```bash
volta install pnpm@5.18.9
```

切换完成后，运行 `pnpm --version` 应该显示 5.18.9，表明我们已经成功切换到旧版本。

以上就是不同的方法和工具来切换和管理不同版本的 PNPM。选择哪种方法取决于个人或项目需求，以及你更习惯使用哪种工具的方式。

如果您已经通过Node.js **corepack**安装了pnpm：

```
corepack enable
```

您可以运行以下命令：

```
corepack prepare pnpm@7.13.6 --activate
```

这里是[文档](https://nodejs.org/api/corepack.html)。


使用**node.js/corepack。** 由于不同的项目需要版本6和7之间进行切换。

在最近版本的node.js（16.17+）中，切换pnpm的最新主要版本更加容易。要获取最新的7.x版本，您可以键入：

```
corepack prepare pnpm@latest --activate
```

要获取最新的6.x版本，您可以键入：

```
corepack prepare pnpm@latest-6 --activate
```

这在pnpm的[安装文档](https://pnpm.io/installation#using-corepack)中也进行了描述。


如果希望使用任何版本的pnpm，可以使用 `npx` 命令：

```
npx pnpm@<version> <command>
```

例如，我已经全局安装了pnpm 8，但是想要为一个依赖于pnpm 6的项目做出贡献。这是我如何做到的：

```
npx pnpm@6 install
```


PNPM（Performant NPM）是一个有效的包管理器，用于处理JavaScript项目中的依赖关系，它类似于npm和Yarn。在PNPM中，如果您想要在项目中切换使用不同版本的包，通常有以下几种方式：

### 1. 使用 `pnpm add` 命令指定版本

当您需要为项目添加一个特定版本的包时，可以使用 `pnpm add` 命令并指定版本号。例如：

```sh
pnpm add lodash@4.17.15
```

这将会安装 `lodash` 包的 `4.17.15` 版本。

### 2. 修改 `package.json` 文件

直接在项目的 `package.json` 文件中指定所需的包版本，然后运行 `pnpm install`。例如：

```json
{
  "dependencies": {
    "lodash": "4.17.15"
  }
}
```

修改完 `package.json` 之后，运行以下命令来安装指定版本的依赖：

```sh
pnpm install
```

### 3. 使用 `.npmrc` 或 `pnpm-workspace.yaml` 配置文件（对于工作区）

如果您在使用PNPM的工作区（monorepo），您可以在 `.npmrc` 或者 `pnpm-workspace.yaml` 文件中指定使用特定版本的包。

在 `.npmrc` 文件中，您可以添加如下配置以锁定特定版本：

```plaintext
lodash=4.17.15
```

在 `pnpm-workspace.yaml` 文件里，可以这样指定：

```yaml
packages:
  - 'packages/*'

dependencies:
  lodash: 4.17.15
```

### 4. 使用 `pnpm update` 命令更新版本

如果您想要更新到一个包的最新版本或一个特定范围内的版本，您可以使用 `pnpm update` 命令。例如：

```sh
# 更新到最新版本
pnpm update lodash

# 更新到特定范围的版本
pnpm update lodash@^4.17.0
```

这会把 `lodash` 更新到最新的版本，或者是符合 `^4.17.0` 范围的最新版本。

### 5. 使用版本管理工具

在维护大型项目或多个项目时，可能需要更复杂的版本管理策略。这时可以使用像 `nvm`(Node Version Manager) 这样的工具来管理不同项目使用的Node.js版本，因为不同的Node.js版本可能会自带或是兼容不同版本的包管理器。

以上就是在PNPM中切换不同版本包的几种常用方法。实际操作中，根据项目需求和团队的开发流程，选择最合适的方法来进行版本管理非常重要。


PNPM相关问题