`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 如何在多个版本之间切换？

在 MongoDB 中，您可以使用 `$slice` 操作符来查询数组的最后一个元素。 `$slice` 可以与 `.find()` 或 `.findOne()` 方法一起使用来指定您想从数组中选择的元素的数量和位置。

如果您只想查询数组的最后一个元素，可以将 `$slice` 设置为 `-1`。以下是一个查询示例，它演示了如何选取数组字段 `arrayField` 中的最后一个元素：

```javascript
db.collection.find({}, { arrayField: { $slice: -1 } })
```

在这个例子中：

- `db.collection` 表示 MongoDB 中的集合。
- `{}` 是查询条件（空，意味着选择所有文档）。
- `{ arrayField: { $slice: -1 } }` 是投影，它指定只返回 `arrayField` 的最后一个元素。

如果您有一个具体的查询条件，并且只想针对满足该条件的文档获取数组的最后一个元素，您可以像这样组合它：

```javascript
db.collection.find({ someField: someValue }, { arrayField: { $slice: -1 } })
```

在这个例子中：

- `{ someField: someValue }` 是查询条件，用以选择具有特定 `someField` 字段值为 `someValue` 的文档。
- `{ arrayField: { $slice: -1 } }` 同样是投影，用来只选择 `arrayField` 中的最后一个元素。

请注意，`$slice` 不仅可以用来获取最后一个元素，还可以用来获取数组的子集，例如获取最后三个元素（`{ $slice: -3 }`）或跳过数组的前两个元素后取两个元素（`{ $slice: [2, 2] }`）。好的，继续补充 `$slice` 的应用，我们可以进一步讨论如何获取数组中的特定范围的元素。这在处理分页或者仅获取感兴趣的部分数据时非常有用。

比如，如果我们想要获取数组中从第二个元素开始的三个元素，我们可以设置 `$slice` 如下：

```javascript
db.collection.find({}, { arrayField: { $slice: [1, 3] } })
```

在这里：

- `[1, 3]` 表示从索引为 `1` （数组的第二个元素）开始获取，然后向后数 `3` 个元素。

此外，MongoDB 也允许你结合使用 `$elemMatch` 查询操作符和 `$slice` 来选择匹配特定条件的数组元素的子集。例如，如果你想要找到含有特定元素的文档，并且仅返回这个元素，可以这样做：

```javascript
db.collection.find({ arrayField: { $elemMatch: { key: value } } }, { 'arrayField.$': 1 })
```

在这个例子中：

- `{ arrayField: { $elemMatch: { key: value } } }` 是查询条件，它会匹配那些在数组 `arrayField` 中至少有一个元素含有键 `key` 并且值为 `value` 的文档。
- `{'arrayField.$': 1}` 是投影，它指定只返回匹配 `$elemMatch` 条件的第一个元素。

结合 `$slice` 和 `$elemMatch` 的高级用法可能会更复杂，但上述的用例展示了如何查询数组的特定部分，包括最后一个元素的常见做法。在实际的应用中，这些技术可以帮助您有效地查询和处理存储在 MongoDB 数组中的数据。

在 3.2 中这是可能的。第一个项目让 myField 只包含最后一个元素，然后在 myField 上进行匹配。

    db.collection.aggregate([
       { $project: { id: 1, myField: { $slice: [ "$myField", -1 ] } } },
       { $match: { myField: "myValue" } }
    ]);

您可以使用[$expr](https://docs.mongodb.com/manual/reference/operator/query/expr/)（3.6 mongo 版本运算符）在常规查询中使用聚合函数。

比较[`query operators`](https://docs.mongodb.com/manual/reference/operator/query/)与[`aggregation comparison operators`](https://docs.mongodb.com/manual/reference/operator/aggregation-comparison/)\_

对于标量数组

    db.col.find({$expr: {$gt: [{$arrayElemAt: ["$array", -1]}, value]}})
    

对于嵌入式数组 - 使用[`$arrayElemAt`](https://docs.mongodb.com/manual/reference/operator/aggregation/arrayElemAt/)带有点表示法的表达式来投影最后一个元素。

    db.col.find({$expr: {$gt: [{"$arrayElemAt": ["$array.field", -1]}, value]}})
    

弹簧`@Query`代码

    @Query("{$expr:{$gt:[{$arrayElemAt:[\"$array\", -1]}, ?0]}}")
    ReturnType MethodName(ArgType arg);

从 开始`Mongo 4.4`，聚合运算符[`$last`](https://docs.mongodb.com/master/reference/operator/aggregation/last-array-element/)可用于访问数组的最后一个元素：

* * *

例如，在`find`查询中：

    // { "myArray": ["A", "B", "C"] }
    // { "myArray": ["D"] }
    db.collection.find({ $expr: { $eq: [{ $last: "$myArray" }, "C"] } })
    // { "myArray": ["A", "B", "C"] }
    

* * *

或者在`aggregation`查询中：

    db.collection.aggregate([
      { $addFields: { last: { $last: "$myArray" } } },
      { $match: { last: "C" } }
    ])

使用**$slice**。

    db.collection.find( {}, { array_field: { $slice: -1 } } )
    

编辑：您可以使用它 `{ <field>: { $elemMatch: { <query1>, <query2>, ... } } }`来查找匹配项。

但它不会准确地给出您正在寻找的内容。我认为这在 mongoDB 中还不可能。

[我在](https://groups.google.com/forum/#!topic/mongodb-user/m2XB6KYs8Fw)Mongo Google 官方群组上发帖，并得到了他们工作人员的答复。看来我正在寻找的东西是不可能的。我将使用不同的模式方法。

Mongoose 如何查询数组的最后一个元素？

在`pnpm`环境中，确实可以使用相似于`npm`中`npx`命令的功能。`npx`是`npm`的一个工具，允许用户运行在没有全局安装的情况下的包。`pnpm`有一个类似的命令叫`pnpx`，但从`pnpm`版本6开始，`pnpx`被标记为废弃，转而推荐直接使用`pnpm dlx`。

`pnpm dlx`命令的作用类似于`npx`，它允许你执行一个在本地未安装的npm包。这样你可以临时运行一个命令，而不需要将其添加到项目的依赖中。举个例子，如果你希望运行`create-react-app`来初始化一个新的React项目，你可以使用下面的命令：

```sh
pnpm dlx create-react-app my-app
```

这条命令将会临时安装`create-react-app`并立刻在`my-app`目录下创建一个新的React应用，而无需将`create-react-app`作为全局或项目的依赖。

使用`pnpm dlx`的好处之一是，它会使用`pnpm`的存储方式，即使是临时安装，也会利用`pnpm`的缓存和存储机制，有效地节省磁盘空间并加快后续的执行速度。

The are are two key uses of `npx`.

**Running executables inside your downloaded dependencies**

For example `npx jest`.

The pnpm equivalent is `pnpm exec jest`.

**Running executable commands in packages you want to download transiently**

For example `npx create-react-app my-app`.

The pnpm equivalent of this is `pnpm dlx create-react-app my-app`.

Note: There used to be a `pnpx` command, but it has been [deprecated](https://web.archive.org/web/20230202163724/https://pnpm.io/6.x/pnpx-cli).

Based on [PNPM Feature Comparison](https://pnpm.io/feature-comparison) the alternative to **NPX** in **PNPM** should `pnpm dlx`

Comment from the [addition of dlx](https://github.com/pnpm/pnpm/pull/3652):

> npx is also kind of deprecated and replaced by `npm exec`.

Which probably refers to npx being [deprecated as standalone package](https://github.com/npm/npx/commit/34660901133c8e890c1076d11b744ea20d9511c2#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5R1) and [inclusion into npm itself by use of `npm exec`](https://docs.npmjs.com/cli/v7/commands/npx#compatibility-with-older-npx-versions) . The [main difference](https://docs.npmjs.com/cli/v7/commands/npx#npx-vs-npm-exec) is now that

**`npm exec` supports `--` to end argument parsing** for itself and count following args to the package to be run.

Whereas **npx** requires all **args to itself** to be given **before the package** to be run and couts all following arguments to the latter.

Short answer yes. `npx create-next-app@latest --use-pnpm`

PNPM 如何使用 npx ？

在Typescript中删除数组中的某一项，通常有几种不同的方法。以下是一些常用的方法，每种方法都有相应的使用场景和示例。

### 1. 使用 `splice` 方法

`splice` 方法可以用来添加或删除数组中的元素。要删除特定的元素，你需要知道该元素的索引。`splice` 的第一个参数是开始修改的数组索引，第二个参数是要删除的元素数量。请注意，`splice` 是一个改变原数组的方法。

**示例：**

```typescript
let numbers = [1, 2, 3, 4, 5];
let indexToRemove = 2; // 我们想要删除数字 3，它的索引是 2
numbers.splice(indexToRemove, 1); // 从索引2的位置开始删除一个元素
console.log(numbers); // 输出: [1, 2, 4, 5]
```

### 2. 使用 `filter` 方法

如果你想要根据元素的值而不是索引来删除元素，或者需要删除满足特定条件的所有项，`filter` 方法是很好的选择。`filter` 创建一个新数组，包含通过提供的函数实现的测试的所有元素，不会改变原数组。

**示例：**

```typescript
let numbers = [1, 2, 3, 4, 5];
let valueToRemove = 3;
numbers = numbers.filter(item => item !== valueToRemove);
console.log(numbers); // 输出: [1, 2, 4, 5]
```

### 3. 使用 `slice` 方法

`slice` 方法可以用来创建数组的一个浅拷贝，从而不改变原数组。如果你知道要删除的元素的索引范围，可以使用 `slice` 来创建不包含这些元素的新数组。

**示例：**

```typescript
let numbers = [1, 2, 3, 4, 5];
let startOfNewArray = numbers.slice(0, 2); // 获取索引0到2（不包括2）的元素
let endOfNewArray = numbers.slice(3); // 获取索引3到数组末尾的元素
numbers = [...startOfNewArray, ...endOfNewArray]; // 使用展开运算符合并数组
console.log(numbers); // 输出: [1, 2, 4, 5]
```

### 4. 使用 `pop` 或 `shift` 方法

如果你想要删除数组的最后一个元素，可以使用 `pop` 方法，同样的，如果你想删除数组的第一个元素，可以使用 `shift` 方法。

**示例：**

```typescript
let numbers = [1, 2, 3, 4, 5];

numbers.pop(); // 删除数组的最后一个元素
console.log(numbers); // 输出: [1, 2, 3, 4]

numbers.shift(); // 删除数组的第一个元素
console.log(numbers); // 输出: [2, 3, 4]
```

你选择哪种方法取决于你的具体需求，比如是否需要原地修改数组、是否已知索引或者删除条件等。在实际的编码工作中，保持代码的可读性和清晰的逻辑也是非常重要的。

Typescript 如何删除数组中某一项？

在TypeScript中，将字符串转换为数字通常有两种常用的方法：使用全局的 `parseInt()` 或 `parseFloat()` 函数，以及使用一元加号运算符。下面是具体的例子：

### 使用 `parseInt()` 和 `parseFloat()`

`parseInt()` 函数用于将字符串解析为整数，而 `parseFloat()` 函数则用于解析为浮点数。

```typescript
let stringValue: string = "123";
let intValue: number = parseInt(stringValue);

// 如果字符串是浮点数表示，可以使用parseFloat来获取浮点数
stringValue = "123.456";
let floatValue: number = parseFloat(stringValue);

console.log(intValue);    // 输出：123
console.log(floatValue);  // 输出：123.456
```

`parseInt()` 函数可以接受第二个参数作为基数，以便解析不同进制的数字字符串。例如，如果你想解析十六进制的字符串，可以这样做：

```typescript
stringValue = "0xF";
intValue = parseInt(stringValue, 16);

console.log(intValue); // 输出：15
```

### 使用一元加号运算符

一元加号运算符（`+`）可以将其紧随的字符串转换成数字：

```typescript
stringValue = "123";
intValue = +stringValue;  // 一元加号

stringValue = "123.456";
floatValue = +stringValue; // 也能够处理浮点数

console.log(intValue);    // 输出：123
console.log(floatValue);  // 输出：123.456
```

这种方法很简洁，但是如果字符串不是合法的数字，则会得到 `NaN`（Not-a-Number）。

### 错误处理

在实际应用中，你通常需要处理可能发生的错误。例如，如果字符串不包含有效的数字，`parseInt()` 和 `parseFloat()` 会返回 `NaN`，而一元加号运算符也是如此。你可能需要在转换后检查结果是否为 `NaN`，并相应地处理：

```typescript
stringValue = "abc";
intValue = parseInt(stringValue);

if (isNaN(intValue)) {
    console.log("parseInt 失败，字符串不包含有效数字");
} else {
    console.log(intValue);
}

// 使用一元加号运算符时的检查
floatValue = +stringValue;

if (isNaN(floatValue)) {
    console.log("一元加号运算符转换失败，字符串不包含有效数字");
} else {
    console.log(floatValue);
}
```

在编写TypeScript代码时，考虑到类型安全和错误处理是非常重要的，以上例子都演示了如何将字符串安全地转换为数字，并如何处理潜在的错误。

[Exactly like](https://stackoverflow.com/questions/1133770/convert-a-string-to-an-integer) [in JavaScript](https://stackoverflow.com/questions/17106681/parseint-vs-unary-plus-when-to-use-which/17106702#17106702), you can use the [`parseInt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt) or [`parseFloat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseFloat) functions, or simply use the unary `+` operator:

    var x = "32";
    var y: number = +x;
    

All of the mentioned techniques will have correct typing and will correctly parse simple decimal integer strings like `"123"`, but will behave differently for various other, possibly expected, cases (like `"123.45"`) and corner cases (like `null`).

[![Conversion table](https://i.stack.imgur.com/QNMfI.png)](https://i.stack.imgur.com/QNMfI.png) Table taken from [this answer](https://stackoverflow.com/a/17106702/1483676)

The TypeScript way to do this would be:

    Number('1234') // 1234
    Number('9BX9') // NaN
    

as answered here: [https://stackoverflow.com/a/23440948/2083492](https://stackoverflow.com/a/23440948/2083492)

For our fellow Angular users:

Within a **template**, `Number(x)` and `parseInt(x)` throws an error, and `+x` has no effect. Valid casting will be `x*1` or `x/1`.

As shown by other answers here, there are multiple ways to do the conversion:

    Number('123');
    +'123';
    parseInt('123');
    parseFloat('123.45')
    

I'd like to mention one more thing on `parseInt` though.

When using `parseInt`, it makes sense to **always pass the radix parameter**. For decimal conversion, that is `10`. This is the default value for the parameter, which is why it _can_ be omitted. For binary, it's a `2` and `16` for hexadecimal. Actually, any radix between and including 2 and 36 works.

    parseInt('123')         // 123 (don't do this)
    parseInt('123', 10)     // 123 (much better)
    
    parseInt('1101', 2)     // 13
    parseInt('0xfae3', 16)  // 64227
    

In some JS implementations, `parseInt` **parses leading zeros as octal**:

> Although discouraged by ECMAScript 3 and forbidden by ECMAScript 5, many implementations interpret a numeric string beginning with a leading 0 as octal. The following may have an octal result, or it may have a decimal result. **Always specify a radix to avoid this unreliable behavior.**
> 
> — [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt#Octal_interpretations_with_no_radix)

The fact that code gets clearer is a nice side effect of specifying the radix parameter.

Since `parseFloat` only parses numeric expressions in radix 10, there's no need for a radix parameter here.

More on this:

*   [Why do we need to use radix? (SO Question)](https://stackoverflow.com/questions/6611824/why-do-we-need-to-use-radix)
*   [SO Answer to "What is the difference between parseInt() and Number()?"](https://stackoverflow.com/a/4090577/3861083)

Expounding on what Ryan said, TypeScript embraces the JavaScript idioms in general.

    var n = +"1"; // the unary + converts to number
    var b = !!"2"; // the !! converts truthy to true, and falsy to false
    var s = ""+3; // the ""+ converts to string via toString()
    

All the interesting in-depth details at [JavaScript Type Conversion](http://jibbering.com/faq/notes/type-conversion/).

Typescript 如何将字符串转换为数字？

在TypeScript中，`unknown`和`any`类型都用于表示可能是任意类型的值，但它们的使用目的和类型安全性方面有所不同。

### `any` 类型

- **类型安全性**: `any`是TypeScript类型系统中一个逃逸舱。当你把一个值标记为`any`类型时，你基本上是在告诉编译器：“相信我，我知道我在做什么，不要对这个值做类型检查。” 这意味着你放弃了TypeScript提供的大部分类型安全性。
  
- **使用情况**: `any`类型通常用在你不想要或者不需要类型检查的场合，比如当你从一个JavaScript项目逐步迁移到TypeScript时，或者当你在处理高度动态的内容时，它可以让你快速编码，不受类型系统的限制。
  
- **例子**: 假设你有一个来自第三方库的函数，该函数返回`any`类型。
  
  ```typescript
  function getDynamicData(): any {
    // 模拟从动态数据源获取数据
    return "I could be anything!";
  }
  
  const dynamicData = getDynamicData();
  dynamicData.foo(); // 编译器不会报错，即使foo方法在运行时不存在
  ```

### `unknown` 类型

- **类型安全性**: 相比之下，`unknown`类型是TypeScript中一个更安全的选择。它表示一个值的类型未知，因此你不能只是对它做任何操作。在对`unknown`类型的值执行大多数操作之前，你需要先进行类型检查或类型断言，以确保操作是安全的。
  
- **使用情况**: 当你的函数或变量可能接受任何类型的值，但你仍然想保留TypeScript的类型检查时，使用`unknown`是一个好选择。它标志着你需要在继续操作之前验证该值的类型。
  
- **例子**: 假设你有一个函数，它接受一个`unknown`类型的参数，并检查它是否为字符串。
  
  ```typescript
  function processUnknownValue(value: unknown) {
    if (typeof value === "string") {
      console.log(value.toUpperCase()); // 类型检查确保这是安全的
    } else {
      console.log("Not a string");
    }
  }
  
  processUnknownValue("hello"); // 输出: "HELLO"
  processUnknownValue(42);      // 输出: "Not a string"
  ```

总结来说，`any`类型在TypeScript中提供了完全的灵活性，允许你在不考虑类型安全的情况下执行任何操作。而`unknown`类型提供了一种方法来表示任何可能的类型，同时仍然需要在执行操作之前进行类型检查，以保持类型安全。在实践中，优先选择`unknown`是更好的习惯，因为它能帮助你写出更安全的代码。

Typescript 中 unkown 与 any 的区别？

Typescript中的`get`和`set`被称为访问器，它们是定义对象属性的特殊方法。`get`方法用于访问属性的值，而`set`方法用于设置属性的值。当你想要在读取或设置属性时加入额外逻辑时，这些方法特别有用。

下面是一个使用TypeScript中的`get`和`set`访问器的示例：

```typescript
class Person {
    private _firstName: string;
    private _lastName: string;

    constructor(firstName: string, lastName: string) {
        this._firstName = firstName;
        this._lastName = lastName;
    }

    // 使用get访问器来获取完整的名字
    get fullName(): string {
        return `${this._firstName} ${this._lastName}`;
    }

    // 使用set访问器来设置姓氏，并执行一些额外的逻辑，比如校验
    set lastName(name: string) {
        if (name.length > 0) {
            this._lastName = name;
        } else {
            console.error('Invalid last name');
        }
    }
}

let person = new Person('John', 'Doe');

// 通过get访问器获取fullName
console.log(person.fullName); // 输出：John Doe

// 通过set访问器修改姓氏
person.lastName = 'Smith';
console.log(person.fullName); // 输出：John Smith

// 尝试设置一个无效的姓氏
person.lastName = ''; // 输出：Invalid last name
```

在上面的例子中，我们定义了一个`Person`类，它有私有属性`_firstName`和`_lastName`。我们为这个类定义了两个访问器：

1. `get fullName()`：这个`get`访问器允许我们获取一个人的全名，它通过将`_firstName`和`_lastName`组合起来返回一个字符串。

2. `set lastName(name: string)`：这个`set`访问器允许我们设置一个人的姓氏。在设置姓氏之前，我们可以在这里加入验证逻辑，比如检查新姓氏是否为空，如果为空，则给出错误消息并拒绝更新。

通过使用`get`和`set`访问器，我们可以封装对象的内部状态，同时提供一个简洁的API来访问和修改这些状态，也可以增加验证或其他必要的逻辑。

Typescropt 如何使用 get 和 set ?

在强制刷新或更新Service Worker时，通常涉及以下几个步骤：

1. **更新Service Worker文件**：
   确保你已经对Service Worker脚本做了修改。即便是很小的改动，如更新文件中的注释，也能触发Service Worker的更新事件，因为浏览器会检查Service Worker文件是否有字节级别的变化。

2. **Service Worker生命周期利用**：
   Service Worker的生命周期中有一个`install`事件。当检测到Service Worker文件有更新时，新的Service Worker将会进入`install`阶段。在这个阶段，你可以清除旧缓存并且执行新的缓存逻辑。

3. **激活新的Service Worker**：
   在新的Service Worker安装后，它会进入`wait`状态。你可以通过调用`self.skipWaiting()`方法来强制当前正在等待的Service Worker立即进入`activate`状态。

4. **更新客户端**：
   新的Service Worker激活后，并不会控制当前打开的页面，直到下次用户访问。为了让新的Service Worker立即接管，可以使用`clients.claim()`方法。

5. **通知用户**：
   如果你希望用户知道有一个新版本可用，并且鼓励他们刷新页面来使用新的Service Worker，可以在页面上显示一个通知或者按钮来提示用户。

### 示例代码

以下是一个简单的Service Worker更新流程实例：

```javascript
// 在Service Worker文件中
self.addEventListener('install', event => {
  // 强制当前正在等待的Service Worker立即进入activate状态
  self.skipWaiting();
});

self.addEventListener('activate', event => {
  // 让新的Service Worker立即接管当前页面
  event.waitUntil(clients.claim());
  // 清理旧版本缓存的逻辑
});
```

```javascript
// 在注册Service Worker的主文件中
if ('serviceWorker' in navigator) {
  navigator.serviceWorker.register('/service-worker.js').then(reg => {
    reg.addEventListener('updatefound', () => {
      const newWorker = reg.installing;
      newWorker.addEventListener('statechange', () => {
        if (newWorker.state === 'installed' && navigator.serviceWorker.controller) {
          // 新的Service Worker已经就绪，可以通知用户刷新页面了
          // 这里可以显示一个“更新可用”的通知或者刷新按钮
        }
      });
    });
  });
}
```

### 强制刷新页面

如果你控制了页面逻辑，你甚至可以在新的Service Worker激活后自动刷新页面，但这通常不是一个好的做法，因为用户可能会丢失未保存的状态。

你可以这样做：

```javascript
if ('serviceWorker' in navigator) {
  navigator.serviceWorker.addEventListener('controllerchange', () => {
    // 当新的Service Worker取得控制权时，刷新页面
    window.location.reload();
  });
}
```

请注意，强制刷新页面可能导致用户体验问题，因此确保在适当的时机执行该操作，例如，当用户完成他们的工作并且页面可以安全地刷新时。

这些步骤和代码示例展示了如何在更新Service Worker时保持页面的正常运作并及时地将更新推送给用户。在实际应用中，会根据具体的业务需求和更新策略来调整这个流程。

As the previous answers stated, there is a 1 day (24hr) built-in limit for the browser to look for updates to the service worker, but what you need to be mindful of is you still need to call `.update()` on your `ServiceWorkerRegistration` object otherwise the original version of the file will be used.

While testing changes in Chrome, I always right-click on the refresh button and select 'Empty Cache and Hard Reset' (options are available when developer tools are open) when working on my service worker script.

'sw-precache' has been superseded by [Workbox](https://workboxjs.org/) which generates hashes for the files you want to precache and adds those to the source code of your service worker (I don't know if `sw-precache` works the same way, Jeff's answer suggests it does). If any of the files you want to precache change -- and you re-run your build -- the updated hashes in your service worker are updated which pretty much guarantees the service worker will be "at least one byte different".

When you reload (`ctrl-r`) or re-visit your app the browser will fetch again the service worker that was registered for it. And, if that service worker has changed, it will be "queued up" to manage the app. But it won't start managing the app until you close all tabs with the app open, and then open a new one.

When you hard refresh (`shift-ctrl-r`) [it’ll always load without a controller](https://github.com/w3c/ServiceWorker/blob/master/explainer.md#so-im-controlling-pages-now) which is not the same as using your new service worker.

For testing during development, I use [skip waiting](https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle#skip_waiting) in devtools to make the new service worker replace the old one without waiting for me to close all the tabs.

If one file's hash changes, that's enough to ensure that the service worker JavaScript file generated by `sw-precache` changes. That, in turn, is enough to trigger the service worker update flow.

If you're not seeing an update flow triggered while testing things out, then it may be due to the service worker JavaScript file being served with HTTP caching headers that cause it to be fetched from the browser's cache rather than the from the network.

See [https://stackoverflow.com/a/38854905/385997](https://stackoverflow.com/a/38854905/385997) for a discussion of how HTTP caching headers come into play, and the best practices with regards to that.

One option that I have implemented from a UX standpoint is calling the unregister method on your service worker. ([https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerRegistration/unregister](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerRegistration/unregister))

Once the unregister process is complete you can:

1.  force the window to refresh (window.location.reload)
2.  Based on your load up process, you can fetch the new service worker which will hopefully cache all your new content.

I have ran into weird issues with the service worker before, so this type of solution allows you to somewhat clear the old cache and refresh the state of your application without forcing users to clear their actual browser cache, while at the same time reloading your application.

EX (How to Unregister):

    serviceworker.unregister()
        .then( unregResult => { 
           //You can check if successful with Promise result 'unregResult'
           window.location.reload();
        })

Store a version number in `service‑worker.js`
=============================================

**A one-character change** in the controlling `service-worker.js` will automatically trigger a PWA update. Hence, if you store the version number in a `const` in this file and change it, an update of the PWA will be triggered.

How the update eventually is handled, is determined by the `service-worker.js`. Different update strategies may be defined in terms of the size and volatility of the PWA assets.

However, there is one **important caveat.** Make sure that the **browser cache expiry directive** set by the `.htaccess` file on your asset server is set to a really short duration (e.g. `hours`) or even to [**none**](https://stackoverflow.com/a/66756683/2192488). Failing to do so, will result in the browser not seeing any change for days to come in the `manifest.json`, nor the `service-worker.js`.

More details about service worker behaviour are available from [Google Web Fundamentals](https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle).

当您希望建立一个新版本的 Service Worker 并替换掉旧版本时，您需要确保新的 Service Worker 可以被安装并且激活，从而更新用户的页面。这个过程通常涉及以下步骤：

1. **更新 Service Worker 文件：** 为了触发 Service Worker 的更新检查，你需要对 Service Worker 的脚本文件做出一些变化。浏览器会比较 Service Worker 文件的字节码来决定是否需要安装一个新版本。

2. **安装新的 Service Worker：** 当浏览器检测到 Service Worker 文件有变化时，它会尝试安装新的 Service Worker。安装过程通常在 `install` 事件中完成。

3. **等待新的 Service Worker 激活：** 默认情况下，新的 Service Worker 在安装后不会立即激活，因为旧的 Service Worker 可能还在控制着当前页面。新的 Service Worker 会处于 waiting 状态，直到当前所有的页面都关闭，它才会被激活。

4. **加速激活过程：** 如果您想要强制新的 Service Worker 立即接管，您可以在新的 Service Worker 中使用 `self.skipWaiting()`，这样它就可以跳过等待直接进入激活状态。

5. **更新客户端页面：** 一旦新的 Service Worker 激活，旧的客户端（页面）需要被更新。可以在新的 Service Worker 的 `activate` 事件中使用 `clients.claim()` 来实现。这将允许新的 Service Worker 立即控制所有客户端。

这里是一个简单的例子，展示了如何在 Service Worker 脚本中使用 `skipWaiting` 和 `clients.claim`：

```javascript
self.addEventListener('install', function(event) {
  // 执行安装步骤
  event.waitUntil(
    // 缓存资源等操作
    self.skipWaiting() // 强制进行 Service Worker 更新
  );
});

self.addEventListener('activate', function(event) {
  event.waitUntil(
    clients.claim() // 让新的 Service Worker 接管页面
  );
});
```

为了从页面脚本中强制刷新 Service Worker，你可以使用以下步骤：

1. 注册 Service Worker（如果尚未注册）。
2. 监听 Service Worker 的更新。
3. 当检测到更新时，可以用 `postMessage` API 发送消息给 Service Worker，要求其强制更新。

例如：

```javascript
if ('serviceWorker' in navigator) {
  navigator.serviceWorker.register('/service-worker.js').then(reg => {
    reg.addEventListener('updatefound', () => {
      const newWorker = reg.installing;
      newWorker.addEventListener('statechange', () => {
        if (newWorker.state === 'installed' && navigator.serviceWorker.controller) {
          // 通知新的 Service Worker 接管控制权
          newWorker.postMessage({ action: 'SKIP_WAITING' });
        }
      });
    });
  });
}

// Service Worker 文件中
self.addEventListener('message', (event) => {
  if (event.data.action === 'SKIP_WAITING') {
    self.skipWaiting();
  }
});
```

这样，您就可以强制刷新/更新 Service Worker 了。记住，虽然可以强制更新 Service Worker，但最好还是确保这样做对用户来说是平滑且不会导致数据丢失的。

对于Service Worker的强制刷新或更新，以下是步骤和考虑事项：

1. **更新 Service Worker 文件**：
   要使浏览器检查更新的 Service Worker，你需要更改 Service Worker 文件 (`service-worker.js` 或任何你命名的文件) 的内容。即使是一个简单的空格或注释的变化，都会导致浏览器认为 Service Worker 已经更新。

2. **Service Worker 生命周期**：
   Service Worker 有一个内建的生命周期，用于管理安装和更新。当一个新的 Service Worker 被检测到，且与现有 Service Worker 不同时，它会进入 `install` 阶段，但不会立即控制页面，而是等待 `activate` 阶段。

3. **跳过等待（Skip Waiting）**：
   默认情况下，新的 Service Worker 会在等待状态，直到所有加载了旧 Service Worker 的页面关闭。为了让新的 Service Worker 立即接管，你可以在 Service Worker 文件中添加 `self.skipWaiting()`，这样新的 Service Worker 在安装结束后会立即进入激活状态。

    ```javascript
    // 在 Service Worker 的 'install' 事件中
    self.addEventListener('install', event => {
        event.waitUntil(
            // 强制进行更新
            self.skipWaiting()
        );
    });
    ```

4. **客户端的 Claim**：
   一旦激活，新的 Service Worker 应该开始接管控制页面。但是，如果你想让 Service Worker 立即控制所有客户端，包括加载旧 Service Worker 的页面，可以使用 `self.clients.claim()` 方法。

    ```javascript
    // 在 Service Worker 的 'activate' 事件中
    self.addEventListener('activate', event => {
        event.waitUntil(
            self.clients.claim()
        );
    });
    ```

5. **更新客户端页面**：
   即使新的 Service Worker 激活并开始控制页面，你也可能需要刷新页面，以确保新的 Service Worker 接管并应用新的缓存策略或其他更新。你可以通过以下方式通知用户刷新页面，或者在某些情况下可以强制刷新。

    ```javascript
    // 通常，你可以提醒用户重新加载页面
    if (navigator.serviceWorker) {
        navigator.serviceWorker.addEventListener('controllerchange', () => {
            // 在这里通知用户或刷新页面
            console.log('Service Worker 已更新。');
            window.location.reload();
        });
    }
    ```

6. **更新缓存**：
   更新了 Service Worker 后，你还需要更新缓存的资源。你可以在 `install` 事件中通过删除旧缓存的方式来做到这一点。

    ```javascript
    self.addEventListener('install', (event) => {
        event.waitUntil(
            caches.keys().then(cacheNames => {
                return Promise.all(
                    cacheNames.map(cache => {
                        if (cache !== currentCacheName) {
                            // 删除旧缓存
                            return caches.delete(cache);
                        }
                    })
                );
            })
        );
    });
    ```

通过使用以上技术，你可以确保 Service Worker 的更新能够快速且强制地推送到客户端，这对于紧急修复错误或推出新功能尤为重要。记住，Service Worker 的更新可能涉及对用户体验的中断，所以应该在用户不太可能被中断的时候进行更新，或者确保前端有相应的提醒和用户引导措施。

Service Worker 如何强制更新？

在TypeScript中，`get`和`set`访问器允许我们有效地封装对象中的属性，通过这种方式可以在读取或写入属性时执行额外的逻辑。`get`访问器用于定义如何读取属性值，而`set`访问器则定义如何设置属性值。下面是一个使用`get`和`set`访问器的例子：

```typescript
class Person {
    private _firstName: string;
    private _lastName: string;

    constructor(firstName: string, lastName: string) {
        this._firstName = firstName;
        this._lastName = lastName;
    }

    // 使用 get 访问器来读取 fullName
    get fullName(): string {
        return `${this._firstName} ${this._lastName}`;
    }

    // 使用 set 访问器来设置 firstName 和 lastName
    set fullName(name: string) {
        const parts = name.split(' ');
        if (parts.length !== 2) {
            throw new Error('请输入一个完整的名字，例如：John Doe');
        }
        this._firstName = parts[0];
        this._lastName = parts[1];
    }
}

let person = new Person('John', 'Doe');

// 通过 get 访问器获取 fullName
console.log(person.fullName); // 输出: John Doe

// 通过 set 访问器修改 fullName
person.fullName = 'Jane Smith';

// 再次通过 get 访问器获取修改后的 fullName
console.log(person.fullName); // 输出: Jane Smith
```

在上述例子中，`Person` 类有两个私有属性 `_firstName` 和 `_lastName`。为了能够控制对这些属性的访问，我们定义了一个 `fullName` 属性，它有一个 `get` 访问器和一个 `set` 访问器。

- `get fullName()` 方法用于在需要时构造并返回一个完整的名字，即 `_firstName` 和 `_lastName` 的组合。
- `set fullName(name: string)` 方法允许我们通过一个字符串来设置 `_firstName` 和 `_lastName`。如果传入的字符串不是两个部分组成，则会抛出错误。

这样，我们就可以用面向对象的方式，封装属性的具体实现细节，同时通过访问器提供简单的接口供外部代码使用。这样做的好处是可以在设置和获取属性时添加验证逻辑或其他附加操作，而不必暴露类的内部结构。

TypeScript uses getter/setter syntax that is like ECMAScript4/ActionScript3.

    class foo {
        private _bar: boolean = false;
        get bar(): boolean {
            return this._bar;
        }
        set bar(value: boolean) {
            this._bar = value;
        }
    }
    

However, in order to use it at all, you must make sure the TypeScript compiler targets ECMAScript5 or higher. If you are running the command line compiler, use `--target` flag like this:

    tsc --target ES5
    

If you are using Visual Studio, you must edit your project file to add the flag to the configuration for the TypeScriptCompile build tool. You can see that [here](https://stackoverflow.com/a/17261732/1733315):

That will produce this JavaScript, using the ECMAScript 5 `Object.defineProperty()` feature.

    var foo = (function () {
        function foo() {
            this._bar = false;
        }
        Object.defineProperty(foo.prototype, "bar", {
            get: function () {
                return this._bar;
            },
            set: function (value) {
                this._bar = value;
            },
            enumerable: true,
            configurable: true
        });
        return foo;
    })();
    

More recent versions of EcmaScript will produce code that looks more like the original TypeScript. For instance, targeting EcmaScript2017 will produce:

    "use strict";
    class foo {
        constructor() {
            this._bar = false;
        }
        get bar() {
            return this._bar;
        }
        set bar(value) {
            this._bar = value;
        }
    }
    

So to use it,

    var myFoo = new foo();
    if(myFoo.bar) {         // calls the getter
        myFoo.bar = false;  // calls the setter and passes false
    }
    

As @DanFromGermany suggests below, if you are simply reading and writing a local property like `foo.bar = true`, then having a setter and getter pair is overkill. You can always add them later if you need to do something, like logging, whenever the property is read or written.

Getters can be used to implement readonly properties. Here is an example that also shows how getters interact with readonly and optional types.

    //
    // type with optional readonly property.
    // baz?:string is the same as baz:string|undefined
    //
    type Foo = {
        readonly bar: string;
        readonly baz?: string;
    }
    const foo:Foo = {bar: "bar"}
    console.log(foo.bar) // prints 'bar'
    console.log(foo.baz) // prints undefined
    
    //
    // interface with optional readonly property
    //
    interface iFoo {
        readonly bar: string;
        readonly baz?: string;
    }
    
    const ifoo:iFoo = {bar: "bar"}
    console.log(ifoo.bar)  // prints 'bar'
    console.log(ifoo.baz)  // prints undefined
    
    
    //
    // class implements bar as a getter, 
    // but leaves off baz.
    //
    class iBarClass implements iFoo {
    
        get bar() { return "bar" }
    }
    const iBarInstance = new iBarClass()
    console.log(iBarInstance.bar) // prints 'bar'
    console.log(iBarInstance.baz) // prints 'undefined'
    // accessing baz gives warning that baz does not exist 
    // on iBarClass but returns undefined
    // note that you could define baz as a getter
    // and just return undefined to remove the warning.
    
    
    //
    // class implements optional readonly property as a getter
    //
    class iBazClass extends iBarClass {
        private readonly _baz?: string
    
        constructor(baz?:string) {
            super()
            this._baz = baz
        }
    
        get baz() { return this._baz; }
    }
    
    const iBazInstance = new iBazClass("baz")
    console.log(iBazInstance.bar)  // prints bar
    console.log(iBazInstance.baz)  // prints baz

Ezward has already provided a good answer, but I noticed that one of the comments asks how it is used. For people like me who stumble across this question, I thought it would be useful to have a link to the official documentation on getters and setters on the Typescript website as that explains it well, will hopefully always stay up-to-date as changes are made, and shows example usage:

[http://www.typescriptlang.org/docs/handbook/classes.html](http://www.typescriptlang.org/docs/handbook/classes.html)

In particular, for those not familiar with it, note that you don't incorporate the word 'get' into a call to a getter (and similarly for setters):

    var myBar = myFoo.getBar(); // wrong    
    var myBar = myFoo.get('bar');  // wrong
    

You should simply do this:

    var myBar = myFoo.bar;  // correct (get)
    myFoo.bar = true;  // correct (set) (false is correct too obviously!)
    

given a class like:

    class foo {
      private _bar:boolean = false;
    
      get bar():boolean {
        return this._bar;
      }
      set bar(theBar:boolean) {
        this._bar = theBar;
      }
    }
    

then the 'bar' getter for the private '\_bar' property will be called.

Here's a working example that should point you in the right direction:

    class Foo {
        _name;
    
        get Name() {
            return this._name;
        }
    
        set Name(val) {
            this._name = val;
        }
    }
    

Getters and setters in JavaScript are just normal functions. The setter is a function that takes a parameter whose value is the value being set.

You can write this

    class Human {
        private firstName : string;
        private lastName : string;
    
        constructor (
            public FirstName?:string, 
            public LastName?:string) {
    
        }
    
        get FirstName() : string {
            console.log("Get FirstName : ", this.firstName);
            return this.firstName;
        }
        set FirstName(value : string) {
            console.log("Set FirstName : ", value);
            this.firstName = value;
        } 
    
        get LastName() : string {
            console.log("Get LastName : ", this.lastName);
            return this.lastName;
        }
        set LastName(value : string) {
            console.log("Set LastName : ", value);
            this.lastName = value;
        } 
    
    }

I think I probably get why is it so confusing. In your example, we wanted getters and setters for `_name`. But we achieve that by creating getters and setters for an unrelated class variable `Name`.

Consider this:

    class Car {
        private tiresCount = 4;
        get yourCarTiresCount(){
            return this.tiresCount;
        }
        set yourCarTiresCount(count) {
            alert('You shouldn\'t change car tire count')
        }
    }
    

Above code does following:

1.  `get` and `set` create getter and setter for `yourCarTiresCount` (**not for `tiresCount`**).

The getter is :

    function () {
        return this.tiresCount;
    }
    

and the setter is :

    function (count) {
        alert('You shouldn\'t change car tire count');
    }
    

Meaning, every time we do `new Car().yourCarTiresCount`, getter runs. And for every `new Car().yourCarTiresCount('7')` setter runs.

2.  **Indirectly** create getter, but not the setter, for private `tireCount`.

Typescript 中如何使用 get 和 set

注册 Service Worker 可能会因为多种原因失败，以下是一些常见的原因及其解释：

### 1. 作用域问题（Scope）
Service Worker 的作用域由其注册时的位置决定。如果你尝试在子目录注册一个 Service Worker，而这个 Service Worker 的作用域是在更高级别的目录，那么注册可能会失败。例如，试图在 `/pages/` 下注册一个 Service Worker，但其作用域是 `/`，浏览器将不会允许这么做。

**例子**：
```javascript
// 假设在 /pages/index.html 中
navigator.serviceWorker.register('/service-worker.js', { scope: '/' })
.then(function(registration) {
  // 注册成功
})
.catch(function(error) {
  // 注册失败，可能是由于作用域问题
});
```

### 2. 路径错误
如果 Service Worker 文件的路径不正确，浏览器无法找到 Service Worker 脚本，也会导致注册失败。

**例子**：
```javascript
// 假设实际的 Service Worker 位于 /scripts/service-worker.js
navigator.serviceWorker.register('/wrong-path/service-worker.js')
.then(function(registration) {
  // 注册成功
})
.catch(function(error) {
  // 注册失败，因为路径不正确
});
```

### 3. 不支持 Service Worker
并非所有的浏览器都支持 Service Worker，尝试在不支持 Service Worker 的浏览器中注册它，自然会失败。

**例子**：
```javascript
if ('serviceWorker' in navigator) {
  // 浏览器支持 Service Worker
  navigator.serviceWorker.register('/service-worker.js')
  .then(function(registration) {
    // 注册成功
  })
  .catch(function(error) {
    // 注册失败
  });
} else {
  // 浏览器不支持 Service Worker
  console.log('Service Worker is not supported by this browser.');
}
```

### 4. 服务工作线程文件中的错误
如果 Service Worker 文件本身存在语法错误或其他问题，它的注册也会失败。

**例子**：
```javascript
// service-worker.js 文件中的语法错误
self.addEventListener('fetch', function(event) {
  // 缺少了闭合的花括号
```

### 5. HTTPS 协议
出于安全原因，Service Worker 只能在 HTTPS 协议下注册成功（除了本地环境，如 `localhost`，可以使用 HTTP）。如果你在非安全的 HTTP 环境下尝试注册 Service Worker，注册将失败。

**例子**：
```javascript
// 尝试在 HTTP 环境下注册 Service Worker
navigator.serviceWorker.register('/service-worker.js')
.then(function(registration) {
  // 注册成功
})
.catch(function(error) {
  // 注册失败，因为不是 HTTPS 环境
});
```

### 6. 浏览器隐私模式
某些浏览器在隐私模式下可能不允许使用 Service Worker，因此尝试在这种模式下注册可能会失败。

### 7. 过时的浏览器缓存
如果浏览器缓存了旧的 Service Worker 文件或注册代码，可能导致注册看似失败，这时候清除缓存可能会解决问题。

针对上述任何注册失败的情况，开发者都应该通过浏览器的开发者工具检查错误信息，以便找到具体的失败原因并解决。通常，注册失败时的 catch 代码块可以获取到错误信息，这对于调试非常有用。

Service worker 为什么注册失败？

Service Worker 控制台通常指的是浏览器开发者工具中与 Service Worker 相关的部分，它允许开发者管理、调试和了解 Service Worker 的状态和行为。Service Worker 是一种运行在浏览器背后、独立于网页的 JavaScript Worker，它可以用来处理离线缓存、推送通知和背景数据同步等功能。

在 Google Chrome 浏览器中，可以通过以下步骤访问 Service Worker 控制台：

1. 打开 Chrome 浏览器。
2. 访问一个使用了 Service Worker 的网站。
3. 右键点击页面，选择“检查”（Inspect），或者使用快捷键`Ctrl+Shift+I`（Windows/Linux）或`Cmd+Opt+I`（Mac）来打开开发者工具。
4. 在开发者工具窗口中，选择“Application”面板。
5. 在“Application”面板的左侧菜单中，找到并点击“Service Workers”。

在这个部分，你可以看到当前网站注册的所有 Service Workers 的信息，包括它们的状态（激活、运行中、停止）、作用域（scope）、以及是否处于调试状态。此外，你还可以对 Service Workers 进行一些操作，比如更新、停止或者删除 Service Worker，或者模拟离线状态来测试 Service Worker 的离线行为。

例如，如果我为我的网站开发了一个 Service Worker 来缓存静态资源，当用户第一次访问网站时，Service Worker 会被安装并激活，之后它会根据预定义的缓存策略缓存一些静态资源。当用户在没有网络连接的情况下再次访问网站时，即使处于离线状态，网站依然可以通过 Service Worker 提供那些已经缓存的资源，从而提升用户体验。

总的来说，Service Worker 控制台是 Chrome 开发者工具中一个非常有用的部分，它为开发者提供了强大的功能来管理和调试 Service Worker。

Go to chrome://serviceworker-internals

Choose any service worker and start it if not already started.

Click on Inspect!!

Boom! You have the console there!

If a page has a service worker, then that service worker's logs show in that page's JavaScript console. You can see the source of a log line on the right-hand side of the log:

[![log line sources](https://i.stack.imgur.com/aKNa3.png)](https://i.stack.imgur.com/aKNa3.png)

In the console, there is a select box to select the _JavaScript context_. This defaults to `top` (which means "show everything"), but you can select a more specific context for just the service worker:

[![selecting alternative context](https://i.stack.imgur.com/HhTQx.png)](https://i.stack.imgur.com/HhTQx.png)

Service Worker 控制台通常指的是开发者工具中与 Service Worker 相关的部分，它可以让开发者查看和管理 Service Workers 的状态、生命周期、以及相关的事件和数据。Service Worker 是一种运行在浏览器背后的脚本，它可以帮助实现离线体验、消息推送和背景同步等功能。

要在 Chrome 浏览器中找到与 Service Worker 相关的控制台，您可以按照以下步骤操作：

1. 打开 Chrome 浏览器。
2. 访问您想要检查 Service Worker 的网站。
3. 点击右上角的三个点按钮，选择“更多工具”，然后在下拉菜单中选择“开发者工具”。也可以直接使用快捷键 `Ctrl+Shift+I`（Windows/Linux）或 `Cmd+Option+I`（Mac）来打开开发者工具。
4. 在开发者工具窗口中，点击上方的“Application”（应用）标签。如果看不到“Application”，可能需要点击“>>”符号来展开隐藏的标签列表。
5. 在左侧的导航栏中，找到并点击“Service Workers”选项。在这里，您可以看到当前活动的 Service Workers，包括它们的状态、脚本URL、是否被控制的页面等信息。
6. 在“Service Workers”选项下，您可以看到诸如“Offline”（离线模式）、“Update on reload”（重新加载时更新）等选项，这些选项可以帮助测试和调试 Service Workers。

例如，如果您正在开发一个支持离线功能的网页应用，您可能会在 Service Worker 中编写代码来缓存某些资源。然后，您可以在 Service Worker 控制台中模拟离线状态，来测试您的网页在没有网络连接时是否能够正确地从缓存中加载资源。

这些工具对于开发者来说非常有用，因为它们可以帮助确保 Service Workers 正确安装、激活、运行，并且能够处理各种事件，从而提升网页应用的性能和用户体验。

Service Worker 控制台是开发者工具（Developer Tools）的一部分，是 Google Chrome 浏览器提供的一个界面，用于检查和管理网页或应用中的 Service Workers。Service Worker 是一种运行在浏览器背后的脚本，可以帮助实现离线体验、消息推送和背景同步等功能。它作为一个独立的线程运行，不依赖于网页直接控制，因此可以在不打开网页的情况下执行任务。

在 Chrome 浏览器中，您可以通过以下步骤访问 Service Worker 控制台：

1. 打开 Chrome 浏览器。
2. 访问您想要检查的网站。
3. 右键点击页面，选择“检查”（或使用快捷键 Ctrl+Shift+I / Cmd+Option+I 打开开发者工具）。
4. 在开发者工具中，切换到“Application”选项卡。
5. 在左侧导航菜单中，找到并展开“Service Workers”部分。

在这里，您可以看到当前域下注册的所有 Service Workers 的详细信息，包括它们的状态（例如，已激活、正在运行或已停止）、作用域、脚本URL、以及是否被控制的页面。您还可以对 Service Workers 进行管理，例如更新、卸载、启用离线功能或者调试 Service Workers。

例如，如果我在开发一个渐进式网络应用（PWA），我会使用 Service Worker 来缓存关键资产，以确保我的应用即使在离线状态下也能提供核心功能。在实施缓存策略后，我会通过 Service Worker 控制台检查 Service Worker 的状态，确保它已正确注册并激活，以及验证缓存行为是否符合预期。

什么是 Service worker 控制台？它在 Chrome 浏览器中的什么位置？

在页面刷新时激活更新后的service worker，通常涉及以下几个步骤：

1. **注册Service Worker：**
   首先，需要在你的网页中注册service worker。这通常在JavaScript的主文件中进行：

   ```javascript
   if ('serviceWorker' in navigator) {
     window.addEventListener('load', function() {
       navigator.serviceWorker.register('/service-worker.js').then(function(registration) {
         // 注册成功
         console.log('ServiceWorker registration successful with scope: ', registration.scope);
       }, function(err) {
         // 注册失败
         console.log('ServiceWorker registration failed: ', err);
       });
     });
   }
   ```

2. **更新Service Worker文件：**
   当你更新了service worker的JavaScript文件（`service-worker.js`），浏览器会检测到文件内容的变化，这时候新的service worker会开始安装流程，但此时不会立即激活。

3. **Install和Activate事件：**
   在service worker文件内部，你可以监听`install`和`activate`事件。新的service worker在安装后通常会进入等待状态，直到所有的客户端（页面）都关闭，然后才会被激活。

   ```javascript
   self.addEventListener('install', event => {
     // 执行安装步骤
   });

   self.addEventListener('activate', event => {
     // 在激活时，通常会清理旧的缓存等
     event.waitUntil(
       // 清理工作
     );
   });
   ```

4. **立即激活新的Service Worker：**
   若要在页面刷新时立即激活新的service worker，可以利用`self.skipWaiting()`方法。在`install`事件中调用这个方法可以使新的service worker跳过等待阶段，直接进入激活状态。

   ```javascript
   self.addEventListener('install', event => {
     event.waitUntil(
       // 安装步骤例如缓存文件等，
       // 然后调用skipWaiting来立即激活service worker
       self.skipWaiting()
     );
   });
   ```

5. **控制页面：**
   即使service worker已经激活，如果页面在安装新的service worker之前就已经打开了，那么你还需要通过`clients.claim()`在activate事件中获取对其控制权。

   ```javascript
   self.addEventListener('activate', event => {
     event.waitUntil(
       clients.claim() // 这个操作会使新的service worker立即控制所有的页面
     );
   });
   ```

6. **页面刷新：**
   你可以在页面上提供一个机制来刷新页面，或者通过service worker通知用户，并使用`window.location.reload()`来刷新页面以使用更新后的service worker。

   ```javascript
   navigator.serviceWorker.addEventListener('controllerchange', () => {
     window.location.reload();
   });
   ```

7. **确保更新的Service Worker被应用：**
   对于已经打开的页面，为了立即应用新的service worker，你可能需要提醒用户刷新页面，或者使用前面提到的`window.location.reload()`强制刷新。

通过以上步骤，页面刷新后，更新后的service worker可以被激活并立即开始控制页面。不过，请注意，强制刷新用户的页面可能会导致用户体验不佳，因此应当谨慎使用。

There are conceptually two kinds of updates, and it isn't clear from your question which we're talking about, so I'll cover both.

Updating content
================

Eg:

*   The text of a blog post
*   The schedule for an event
*   A social media timeline

These will likely be stored in the cache API or IndexedDB. These stores live independently of the service worker - updating the service worker shouldn't delete them, and updating them shouldn't require an update to the service worker

Updating the service worker is the native equivalent of shipping a new binary, you shouldn't need to do that to (for example) update an article.

When you update these caches is entirely up to you, and they aren't updated without you updating them. I cover a number of patterns in the [offline cookbook](https://jakearchibald.com/2014/offline-cookbook/), but [this is my favourite one](https://jakearchibald.com/2014/offline-cookbook/#cache-then-network):

1.  Serve page shell, css & js from a cache using the service worker.
2.  Populate page with content from the cache.
3.  Attempt to fetch content from the network.
4.  If the content is fresher than what you have in the cache, update the cache and the page.

In terms of "update the page", you need to do that in a way that isn't disruptive to the user. For chronological lists this is pretty easy, as you just add the new stuff to the bottom/top. If it's updating an article it's a bit trickier, as you don't want to switch text from underneath the user's eyes. In that case it's often easier to show some kind of notification like "Update available - **show update**" which, when clicked, refreshes the content.

[Trained to thrill](https://jakearchibald.github.io/trained-to-thrill/) (perhaps the first ever service worker example) demonstrates how to update a timeline of data.

Updating the "app"
==================

This is the case where you _do_ want to update the service worker. This pattern is used when you're:

*   Updating your page shell
*   Updating JS and/or CSS

If you want the user to get this update in a non-atomic, but fairly safe way, there are patterns for this too.

1.  Detect updated service worker "waiting"
2.  Show notification to user "Update available - **update now**"
3.  When the user clicks this notification, postmessage to the service worker, asking it to call `skipWaiting`.
4.  Detect the new service worker becoming "active"
5.  `window.location.reload()`

Implementing this pattern is part of my [service worker Udacity course](https://www.udacity.com/course/offline-web-applications--ud899), and [here's the diff of the code before/after](https://github.com/jakearchibald/wittr/compare/task-update-notify...update-interaction).

You can take this further too. For example, you could employ some kind of semver-esque system, so you know the version of the service worker the user currently has. If the update is minor you may decide calling `skipWaiting()` is totally safe.

I wrote a blog post explaining how to handle this. [https://redfin.engineering/how-to-fix-the-refresh-button-when-using-service-workers-a8e27af6df68](https://redfin.engineering/how-to-fix-the-refresh-button-when-using-service-workers-a8e27af6df68)

I also have a working sample on github. [https://github.com/dfabulich/service-worker-refresh-sample](https://github.com/dfabulich/service-worker-refresh-sample)

There are four approaches:

1.  **`skipWaiting()` on installation.** This is dangerous, because your tab can get a mix of old and new content.
2.  **`skipWaiting()` on installation, and refresh all open tabs on `controllerchange`** Better, but your users may be surprised when the tab randomly refreshes.
3.  **Refresh all open tabs on `controllerchange`; on installation, prompt the user to `skipWaiting()` with an in-app "refresh" button.** Even better, but the user has to use the in-app "refresh" button; the browser's refresh button still won't work. This is documented in detail in [Google's Udacity course on Service Workers](https://www.udacity.com/course/offline-web-applications--ud899) and the [Workbox Advanced Guide](https://developers.google.com/web/tools/workbox/guides/advanced-recipes#offer_a_page_reload_for_users), as well as the `master` branch of my [sample on Github](https://github.com/dfabulich/service-worker-refresh-sample).
4.  **Refresh the last tab if possible.** During fetches in `navigate` mode, count open tabs ("clients"). If there's just one open tab, then `skipWaiting()` immediately and refresh the only tab by returning a blank response with a `Refresh: 0` header. You can see a working example of this in the `refresh-last-tab` branch of my [sample on Github](https://github.com/dfabulich/service-worker-refresh-sample/tree/refresh-last-tab).

Putting it all together...

In the Service Worker:

    addEventListener('message', messageEvent => {
        if (messageEvent.data === 'skipWaiting') return skipWaiting();
    });
    
    addEventListener('fetch', event => {
        event.respondWith((async () => {
            if (event.request.mode === "navigate" &&
            event.request.method === "GET" &&
            registration.waiting &&
            (await clients.matchAll()).length < 2
            ) {
                registration.waiting.postMessage('skipWaiting');
                return new Response("", {headers: {"Refresh": "0"}});
            }
            return await caches.match(event.request) ||
            fetch(event.request);
        })());
    });
    

In the page:

    function listenForWaitingServiceWorker(reg, callback) {
        function awaitStateChange() {
            reg.installing.addEventListener('statechange', function () {
                if (this.state === 'installed') callback(reg);
            });
        }
        if (!reg) return;
        if (reg.waiting) return callback(reg);
        if (reg.installing) awaitStateChange();
        reg.addEventListener('updatefound', awaitStateChange);
    }
    
    // reload once when the new Service Worker starts activating
    var refreshing;
    navigator.serviceWorker.addEventListener('controllerchange',
        function () {
            if (refreshing) return;
            refreshing = true;
            window.location.reload();
        }
    );
    function promptUserToRefresh(reg) {
        // this is just an example
        // don't use window.confirm in real life; it's terrible
        if (window.confirm("New version available! OK to refresh?")) {
            reg.waiting.postMessage('skipWaiting');
        }
    }
    listenForWaitingServiceWorker(reg, promptUserToRefresh);

In addition to Dan's answer;

**1\. Add the `skipWaiting` event listener in the service worker script.**

In my case, a CRA based application I use [cra-append-sw](https://github.com/bbhlondon/cra-append-sw) to add this snippet to the service worker.

> **Note:** if you are using a recent version of `react-scripts`, the snippet below is [automatically added](https://github.com/GoogleChrome/workbox/issues/2394) and you won't need to use `cra-append-sw`.

    self.addEventListener('message', event => {
      if (!event.data) {
        return;
      }
    
      if (event.data === 'SKIP_WAITING') {
        self.skipWaiting();
      }
    });
    

**2\. Update register-service-worker.js**

For me, it felt natural to reload the page when the user navigates within the site. In the register-service-worker script I've added the following code:

    if (navigator.serviceWorker.controller) {
      // At this point, the old content will have been purged and
      // the fresh content will have been added to the cache.
      // It's the perfect time to display a "New content is
      // available; please refresh." message in your web app.
      console.log('New content is available; please refresh.');
    
      const pushState = window.history.pushState;
    
      window.history.pushState = function () {
        // make sure that the user lands on the "next" page
        pushState.apply(window.history, arguments);
    
        // makes the new service worker active
        installingWorker.postMessage('SKIP_WAITING');
      };
    } else {
    

Essentially we hook into the native `pushState` function so we know that the user is navigating to a new page. Although, if you also use filters in your URL for a products page, for example, you may want to prevent reloading the page and wait for a better opportunity.

Next, I'm also using Dan's snippet to reload all tabs when the service worker controller changes. This also will reload the active tab.

      .catch(error => {
        console.error('Error during service worker registration:', error);
      });
    
    navigator.serviceWorker.addEventListener('controllerchange', () => {
      if (refreshing) {
        return;
      }
    
      refreshing = true;
      window.location.reload();
    });

Even though the OP has disagreed with skipWaiting, skipWaiting is actually the correct solution for many apps, especially single page apps.

Open your precache in DevTools, check if there are any lazy loaded files. If there aren't - meaning everything in your precache are fetched immediately on page load, then it's safe to call skipWaiting, which will delete the old precache, replace with new assets (including the new index.html), waiting to be served on the next refresh. Since all the old assets are already in memory, which are running with the old index.html, there's nothing wo worry about.

(If you see a file in the precache but you aren't sure whether it's downloaded on page load, reload and watch the network traffic in DevTools yourself)

If you do have lazy loaded assets, then it indeed could cause a problem, but that's not a new problem created by service worker. Imagine your user opened a tab, then you deploy a new version, then the user clicks something which triggers a lazy load, but that asset is no longer on your server. This is an old problem. Precache unintentionally solved this problem, but you shouldn't rely on it, instead you should have your own exception handling logic, unless your app was designed to leverage the precache from the very beginning.

如何在页面刷新时激活更新后的service worker？

Service Worker 的作用域（Scope）定义了它能够控制的内容范围，即 Service Worker 可以拦截和处理哪些请求。作用域是通过 Service Worker 注册时指定的，一般来说，Service Worker 只能控制其注册所在路径和下级路径的请求。

例如，如果您在 `/app/` 路径下注册了一个 Service Worker，它的作用域将被限制在 `/app/` 及其子路径下。这意味着，Service Worker 可以拦截 `/app/`、`/app/home`、`/app/settings` 等路径的请求，但它无法控制 `/` 根路径或 `/other` 路径下的请求。

这个作用域的限定有助于确保 Service Worker 不会影响到其它不相关的页面和应用，提供了一种安全的方式来限制 Service Worker 的控制范围。

举个例子，如果一个在线商城网站在其根目录下注册了 Service Worker，并设置了根目录为作用域，那么这个 Service Worker 将能控制商城网站的所有页面。然而，如果商城网站希望仅仅对产品目录页面使用 Service Worker 来缓存和提供离线支持，那么它可以单独在 `/products/` 路径下注册一个 Service Worker，将作用域限制在这个子目录中。这样，Service Worker 只会影响 `/products/` 路径下的请求，而不会影响到其他页面。

Service workers are basically a proxy between your web application and the internet, so it can intercept calls to the network if so desired.

Scope in this instance refers to the path that the service worker will be able to intercept network calls from. The `scope` property can be used explicitly define the scope it will cover. However:

Service workers can only intercept requests originating in the scope of the current directory that the service worker script is located in and its subdirectories. [Or as MDN states](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Why_is_my_service_worker_failing_to_register):

> The service worker will only catch requests from clients under the service worker's scope.
> 
> The max scope for a service worker is the location of the worker.

As your service worker is located in `/static/mod/practice/`, it's not allowed to set its scope to `/practice/foopage/`. Requests to other hosts, e.g. `https://stackoverflow.com/foo`, can be intercepted in any case.

The easiest way to ensure that your service worker can intercept all the calls it needs to, would be to place it in the root directory of your web app (`/`). You can also override the default restrictions using an http header and manually setting the scope (see Ashraf Sabry's answer).

Leave the service worker file in whatever directory imposed by your project structure and set the `scope` option to `/` and add the `Service-Worker-Allowed` HTTP header to the response of your service worker file.

I'm using IIS, so I would add the following to web.config file:

    <location path="static/mod/practice/service-worker.js">
        <system.webServer>
            <httpProtocol>
                <customHeaders>
                    <add name="Service-Worker-Allowed" value="/" />
                </customHeaders>
            </httpProtocol>
        </system.webServer>
    </location>
    

And register the worker by:

    navigator.serviceWorker.register('/static/mod/practice/service-worker.js', { scope: '/' })
            .then(function (registration)
            {
              console.log('Service worker registered successfully');
            }).catch(function (e)
            {
              console.error('Error during service worker registration:', e);
            });
    

Tested on Firefox and Chrome.

Refer to the examples in [Service worker specification](https://w3c.github.io/ServiceWorker/#service-worker-script-response)

For the people who are using nginx it couldn't be any simpler:

    # Given that /static is your route to assets
    location /static {
            # using / as root scope
            add_header Service-Worker-Allowed /;
    ....

Just in case if the scope changes between development & production environment, as often we use local subdirectories for projects, using "./" for the scope may save the day (& make it dynamic).

    navigator.serviceWorker.register(
        `./service-worker.js`, 
        {
            scope: `./`
        }
    );

Service worker 的作用域是什么？

Service Worker 在 React JS 中是一个运行在浏览器背后的脚本，它不依赖于网页而独立工作，能够为应用提供不依赖网络的特性，比如离线内容的访问、背景同步和推送通知等。它相当于一个位于浏览器与网络之间的代理，可以截获和处理网络请求，以及根据需求管理缓存。

Service Worker 在 React 应用中的一个典型用途是创建渐进式网络应用（PWA）。PWA 是一种通过网络技术构建的应用程序，它可以提供类似原生应用的用户体验。通过使用 Service Worker，React 应用可以在用户的设备上缓存应用的核心文件，这样即使在没有网络连接的情况下，用户也能加载应用的基本界面和功能。

一个实际的例子是，当开发者使用 `create-react-app` 工具新建一个 React 项目时，生成的模板项目中自带了 Service Worker 的配置。这个配置默认是不启用的，但是开发者可以选择启用它，并根据实际需要对其进行配置，从而让应用具备 PWA 的特性。

启用 Service Worker 后，当用户首次访问 React 应用时，Service Worker 被安装并开始缓存应用的资源，如 HTML、CSS、JavaScript 文件和图片等。当用户再次访问该应用时，即使在离线状态下，Service Worker 也可以通过拦截请求并提供缓存的资源来加载应用。

Service Worker 还允许开发者通过编程方式精细控制缓存策略，例如决定哪些资源需要缓存、何时更新缓存、如何响应资源请求等。通过这种方式，可以优化应用的性能并提高用户体验。

You may not need a service worker for your application. If you are creating a project with create-react-app it is invoked by default

Service workers are well explained in this **[article](https://developers.google.com/web/fundamentals/primers/service-workers/)**. To Summarise from it

> A `service worker` is a script that your browser runs in the background, separate from a web page, opening the door to features that don't need a web page or user interaction. Today, they already include features like `push notifications` and `background sync` and have `ability to intercept and handle network requests`, including `programmatically managing a cache of responses`.
> 
> In the future, service workers might support other things like `periodic sync` or `geofencing`.

According to this **[PR to create-react-app](https://github.com/facebook/create-react-app/pull/1728)**

> `Service workers` are introduced with create-react-app via `SWPrecacheWebpackPlugin`.
> 
> Using a server worker with a cache-first strategy offers performance advantages, since the network is no longer a bottleneck for fulfilling navigation requests. It does mean, however, that developers (and users) will only see deployed updates on the "N+1" visit to a page, since previously cached resources are updated in the background.

The call to `register service worker` is enabled by default in new apps but you can always remove it and then you’re back to regular behaviour.

**In simple and plain words, it’s a script that browser runs in the background and has whatsoever no relation with web pages or the DOM, and provide out of the box features. It also helps you cache your assets and other files so that when the user is offline or on slow network.**

_Some of these features are proxying network requests, push notifications and background sync. Service workers ensure that the user has a rich offline experience._

You can think of the service worker as someone who sits between the client and server and all the requests that are made to the server pass through the service worker. Basically, a middle man. Since all the request pass through the service worker, it is capable to intercept these requests on the fly.

[![enter image description here](https://i.stack.imgur.com/ldRJk.png)](https://i.stack.imgur.com/ldRJk.png)

I'd like to add 2 important considerations about Service Workers to take into account:

1.  Service Workers require HTTPS. But to enable local testing, this restriction doesn't apply to `localhost`. This is for security reasons as a Service Worker acts like a _man in the middle_ between the web application and the server.
    
2.  With **Create React App** Service Worker is only enabled in the production environment, for example when running `npm run build`.
    

Service Worker is here to help developing a [Progressive Web App](https://web.dev/what-are-pwas/). A good resource about it in the context of Create React App can be found in their website [here](https://create-react-app.dev/docs/making-a-progressive-web-app/).

React js 中的 Service Worker 是什么?

Service Worker 本身并不提供存储功能，但它常常与浏览器中的缓存 API 配合使用，来缓存应用资源。Service Worker 的缓存容量并不是由 Service Worker API 本身强制规定的，而是取决于浏览器的实现和用户设备的可用空间。

每个浏览器可能有不同的存储限制政策，并且这些政策可能会随着时间而改变。大多数现代浏览器都采用启发式方法动态管理每个原始站点（origin）的存储限额。通常，浏览器允许单个原始站点使用的存储量在几十到几百兆字节之间，这取决于用户设备上的总可用空间。

例如，Chrome 浏览器为所有网站的存储限制提供了一个动态配额，它通常是基于每个原始站点可用磁盘空间的一部分。这一部分可能在总磁盘空间的2-5%之间，但这个数字是不固定的，并且可能会根据不同的设备和用户的存储使用情况而变化。

为了给您一个实际的例子，假设用户设备上的可用空间为100GB，Chrome可能会为一个原始站点分配2GB作为最大存储限额。但请记住，这个限额是动态计算的，用户的存储使用情况和浏览器的策略会影响这个值。

总的来说，Service Worker 的缓存大小限制并不是固定不变的，它受多种因素影响，包括浏览器实现、设备存储容量、其他网站的存储使用情况等。开发者可以通过浏览器的配额管理 API 来检查可用存储量，并相应地管理缓存策略。

**Update Jan 15 2018**

The [StorageManager](https://developer.mozilla.org/en-US/docs/Web/API/StorageManager) interface of Storage API is becoming a standard for all storage related api queries. As mentioned by [@miguel-lattuada](https://stackoverflow.com/a/46933005/1657018), the [estimate API](https://developer.mozilla.org/en-US/docs/Web/API/StorageManager/estimate) would provide an estimate of the storage used a web app the available storage. Also, note the [QuotaExceededError](https://developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededError) exception which would help us in handling error scenarios.

eg code:

    if ('storage' in navigator && 'estimate' in navigator.storage) {
      navigator.storage.estimate().then(({usage, quota}) => {
        console.log(`Using ${usage} out of ${quota} bytes.`);
      }).catch(error => {
        console.error('Loading storage estimate failed:');
        console.log(error.stack);
      });
    } else {
      console.error('navigator.storage.estimate API unavailable.');
    }

Run code snippetHide results

Expand snippet

For more info, refer the following 2 great articles:

*   [MDN Web docs - Storage API](https://developer.mozilla.org/en-US/docs/Web/API/Storage_API)
*   [Google Developers: Estimating Available Storage Space](https://developers.google.com/web/updates/2017/08/estimating-available-storage-space)

* * *

**March 16 2017 (keeping it just for reference/history)**

Recently I came across this article: [offline-cookbook](https://jakearchibald.com/2014/offline-cookbook/#cache-persistence) which states as below:

Your **origin is given a certain amount of free space** to do what it wants with. That **free space is shared between all origin storage**: LocalStorage, IndexedDB, Filesystem, and of course Caches.

The **amount you get isn't spec'd**, it will differ depending on device and storage conditions. You can find out how much you've got via:

    navigator.storageQuota.queryInfo("temporary").then(function(info) {
       console.log(info.quota);
       // Result: <quota in bytes>
       console.log(info.usage);
       // Result: <used data in bytes>
    });
    

The above code [might not work in all the browsers](https://developer.mozilla.org/en-US/docs/Web/API/StorageQuota). (for eg: in chrome<48 one might have to look for webkitPersistentStorage etc)

**Other useful info/resources**

1.  As per [Offline Storage for Progressive Web Apps](https://medium.com/dev-channel/offline-storage-for-progressive-web-apps-70d52695513c#.19w8r1c4o) by Addy Osmani
    
    In `Chrome and Opera`: Your storage is per origin (rather than per API). Both storage mechanisms will store data until the browser quota is reached. Apps can check how much quota they’re using with the Quota Management API (as described above).
    
    `Firefox` no limits, but will prompt after 50MB data stored
    
    `Mobile Safari` 50MB max
    
    `Desktop Safari` unlimited (prompts after 5MB)
    
    `IE10+` maxes at 250MB and prompts at 10MB
    
2.  A more detailed guide on [Working with quota on mobile browsers](https://www.html5rocks.com/en/tutorials/offline/quota-research/) by Eiji Kitamura.
    

For now these are the most relevant articles/solutions found for my problem. If anyone knows some better article or specifications please share.

There's no explicit limit. All modern browsers are multi-process or similar, so a badly-designed page (or SW) won't do anything worse than crash itself.

Note that the SW spec is very explicit about the browser being able to kill and restart the SW at any time, for any reason. (If DevTools is open on a page, Chrome purposely kills SWs for the page constantly, to encourage you to adopt good practices.)

On latests browser you can use [StorageManager](https://developer.mozilla.org/en-US/docs/Web/API/StorageManager) which is an implementation of a new standard for browser storage, take a look at [this](https://developer.mozilla.org/en-US/docs/Web/API/Storage_API) mozilla article.

    let _storageStats = await navigator.storage.estimate();
    console.log(_storageStats);
    /*
      Will prompt something like this
      {quota: 15946471833, usage: 682}
      Which is a representation of quota/usage in bytes
      As you can see I get an insane quota of almost 16 GB
    */

Run code snippetHide results

Expand snippet

More info about `navigator.storage.estimate()` and `navigator.webkitTemporaryStorage.queryUsageAndQuota()` is here [https://developers.google.com/web/updates/2017/08/estimating-available-storage-space](https://developers.google.com/web/updates/2017/08/estimating-available-storage-space)

Testing page is here [https://thimbleprojects.org/startpolymer/361372/](https://thimbleprojects.org/startpolymer/361372/)

Service Worker 的存储限制是多少?

在 Progressive Web Application (PWA) 中，Service Worker 是一种运行在浏览器后台的脚本，负责管理缓存以及使应用能够在离线时工作。更新 Service Worker 管理的文件通常遵循以下流程：

### 文件更新流程：

1. **安装 Service Worker**：
   当用户首次访问 PWA 或者 Service Worker 文件 (`service-worker.js`) 有更新时，浏览器会尝试安装新的 Service Worker。这时，Service Worker 的 `install` 事件被触发。

2. **缓存新文件**：
   在 `install` 事件的处理函数中，通常会编写代码来打开缓存，并使用 `cache.addAll()` 方法缓存一个文件列表。此时，可以决定需要缓存哪些新文件或更新的文件。

3. **激活新的 Service Worker**：
   安装完成后，新的 Service Worker 会进入 `waiting` 状态。当网站上没有任何页面使用旧的 Service Worker 时，新的 Service Worker 会接收到 `activate` 事件。在 `activate` 事件的处理函数中，通常会清理旧缓存。

4. **管理旧缓存**：
   在激活阶段，可以通过比较缓存的版本来决定是否删除旧缓存中的文件，或者是整个旧缓存。这是通过 `caches.delete` 方法实现的。

5. **更新完成**：
   一旦新的 Service Worker 被激活并且旧缓存被清理，新的缓存开始生效，之后的网络请求都将通过新的 Service Worker 来处理。通过这个方式，文件得以更新。

### 何时更新：

- **Service Worker 文件变更**：
  每次用户访问 PWA 时，浏览器都会检查 Service Worker 文件是否有变更。如果检测到文件内容有一字节的改动，浏览器会认为 Service Worker 更新了，并开始上述的安装过程。

- **开发者触发更新**：
  开发者可以通过更改 Service Worker 文件，例如更新缓存文件的列表、修改缓存策略等来触发更新。开发者也可以通过版本号的方式来控制缓存的更新。

- **用户清空浏览器缓存**：
  如果用户清空了浏览器缓存，下次访问时 Service Worker 将会重新安装，意味着文件必须重新缓存。

### 示例：

在 Service Worker 的安装阶段，一个常见的更新文件的例子如下：

```javascript
const CACHE_NAME = 'cache-v1';
const URLS_TO_CACHE = [
  '/',
  '/styles/main.css',
  '/script/main.js'
];

self.addEventListener('install', (event) => {
  event.waitUntil(
    caches.open(CACHE_NAME)
    .then((cache) => {
      console.log('Opened cache');
      return cache.addAll(URLS_TO_CACHE);
    })
  );
});

self.addEventListener('activate', (event) => {
  const cacheWhitelist = [CACHE_NAME];
  event.waitUntil(
    caches.keys().then((cacheNames) => {
      return Promise.all(
        cacheNames.map((cacheName) => {
          if (cacheWhitelist.indexOf(cacheName) === -1) {
            return caches.delete(cacheName);
          }
        })
      );
    })
  );
});
```

在这个示例中，我们定义了一个缓存名称和需要缓存的文件列表。在 `install` 事件中，我们打开指定的缓存并添加了需要的文件。在 `activate` 事件中，我们移除了不在白名单中的所有旧缓存。这样，当 Service Worker 文件更新后，新的缓存策略就会生效，旧的文件被更新。

**No cache scenario (No Service worker):** Your PWA app will be cached only when you use Service worker. Manifest.json will help adding your web app to home screen with a icon and open without address bar. If you don't have a service worker or if your browser don't support it, web page will be loaded fresh every single time. No Cache.

**Cache-On Scenario (With Service worker):** Assuming you have service workers configured, service workers can cache by lazy loading or prefetching the files that are configured for caching (You can include or exclude caching anything from html, CSS, images to JSON/XML API responses).

After the initial cache, service worker will use the cache to serve your apps network request based on [cache approach](https://developers.google.com/web/ilt/pwa/caching-files-with-service-worker) you have implemented from below ones.

*   cache falling back to network
*   Network falling back to cache
*   Cache then network

Most apps choose to [precache](https://github.com/GoogleChromeLabs/sw-precache) due to performance benefits and look for new files on loading, if any changes found will be loaded on next session or prompt user to refresh. With this solution, each file will have a long Hash string for each file cached by service worker. On load of each application, hash code from server will be fetched to match and find what file needs to be updated and the same will be updated in a separate service worker thread. You can notice this in network tab -> service worker response in chrome developer tools.

If you choose network-first approach, you can avoid showing old content on initial load, but loose significant performance benefits that comes with caching.

Only two events…
================

In essence, there are **only two events** that will automatically trigger a PWA update:

1.  A change in the linked `manifest.json`; e.g. a changed icon file or a changed `scope` or `start_url`.
2.  A one-character change in the controlling `service-worker.js`. Hence, if you store the version number in a `const` in this file and change it, an update of the PWA will be triggered.

When a change is detected, the new version will normally be activated only with the next PWA load. So, in all, **two reloads** are necessary to see a change.

How the update eventually is handled, is ultimately determined by the `service-worker.js`. Different update strategies may be defined in terms of the size and volatility of the PWA assets. It is also possible to activate a new service immediately.

However, there is one **important caveat.** Make sure that the **browser cache expiry directive** set by the `.htaccess` file of your asset server is set to a really short duration (e.g. `hours`) or even to [**none**](https://stackoverflow.com/a/66756683/2192488). Failing to do so, will result in the browser not seeing any change for days to come in the `manifest.json` nor the `service-worker.js`.

More details about service worker behaviour are available from [Google Web Fundamentals](https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle).

所有问题