常用

🔑 模式切换

🏃 光标移动

基础移动

高级跳跃

✂️ 文本编辑

删除操作

复制粘贴

撤销重做

其他编辑

🎯 选择操作（可视模式）

进入选择模式

文本对象选择

选区操作命令

1
2
3
4
5
6
7
8
9
10

# 在选区后直接输入操作命令：
d    # 删除选区
y    # 复制选区
c    # 修改选区（删除并进入插入模式）
>    # 向右缩进
<    # 向左缩进
=    # 自动缩进
~    # 大小写转换
u    # 转为小写（仅选区）
U    # 转为大写（仅选区）

🔍 搜索替换

🪟 窗口管理

📚 高效技巧

宏录制

1. qa - 开始录制宏到寄存器a
2. 执行操作序列
3. q - 停止录制
4. @a - 执行宏
5. 5@a - 重复执行5次

文本对象操作

批量操作

1
2
3
4

1. Ctrl+v 进入块选择模式
2. 选择多行区域
3. Shift+i 输入内容
4. ESC 应用到所有行

🔄 撤销+选择联合应用案例

1. 错误删除恢复

   • 误删文本 → 按 u 撤销
   • 发现撤销过头 → 按 Ctrl+r 重做

2. 选区批量修改

   1 2 3 4 5 6

   Ctrl+v # 进入块选择 jjj # 向下选3行 I # 块插入 // # 输入注释符 ESC # 三行同时添加"//" u # 若出错立即撤销

3. 复杂回退

   • 修改了30行代码后发现问题
   • :undolist 查看历史节点
   • :undo 2 回到第2个历史状态

4. 选区撤销技巧

   • 选择多行按 = 自动缩进
   • 结果不理想 → 保持选区状态按 u
     （仅撤销选区内的操作！）

🌟 高级组合技

1. 快速注释：Ctrl+v → 选择行 → I → # → ESC
2. 多行缩进：V → 选择行 → > / <
3. 重复操作：. (重复上次编辑操作)
4. 文件内查找：gd (跳转到定义)
5. 打开文件：:e path/to/file
6. 标签导航：Ctrl+^ 切换最近两个文件

💡 提示：在命令模式输入 :help key-notation 查看完整快捷键文档

很多情况刚刚改了环境变量但是又不想重启该软件，使用一下方法刷新环境变量：

CMD：

1
2
3
4

:: 刷新用户变量
set PATH=%USERPROFILE%\AppData\Local\Microsoft\WindowsApps;%PATH%
:: 刷新系统变量（需要管理员权限）
set PATH=%SystemRoot%\system32;%PATH%

PowerShell：

1
2

# 刷新用户变量和系统变量
$env:Path = [System.Environment]::GetEnvironmentVariable("Path","User") + ";" + [System.Environment]::GetEnvironmentVariable("Path","Machine")

如何在命令行设置变量？以下是几种常用的方法：

临时设置环境变量

在命令提示符（cmd）中，您可以使用以下命令来临时设置环境变量。这些变量在关闭命令提示符窗口后就会失效。

1

set 变量名=变量值

例如，设置一个名为MY_VARIABLE的环境变量，值为Hello：

1

set MY_VARIABLE=Hello

您可以通过以下命令来查看变量值：

1

echo %MY_VARIABLE%

永久设置环境变量

要永久设置环境变量，您需要将其添加到系统的环境变量列表中。可以通过以下命令：

• 对于当前用户：

  1	setx 变量名 "变量值"

• 对于所有用户（需要管理员权限）：

  1	setx 变量名 "变量值" /M

  请注意，使用setx设置的变量不会立即生效，它们将在新的命令提示符窗口中生效。

在PowerShell中设置环境变量

在PowerShell中，您可以使用以下命令来设置环境变量：

• 临时设置：

  1	$env:变量名="变量值"

• 永久设置当前用户的环境变量：

  1	[Environment]::SetEnvironmentVariable("变量名", "变量值", [EnvironmentVariableTarget]::User)

• 永久设置所有用户的环境变量（需要管理员权限）：

  1	[Environment]::SetEnvironmentVariable("变量名", "变量值", [EnvironmentVariableTarget]::Machine)

• 在 GitHub Actions 中，工作流（workflow）由多个任务（job）组成，每个任务包含一系列步骤（step）。核心概念如下：

• Workflow（工作流）：定义自动化流程的 YAML 配置文件，存放在 .github/workflows/ 目录下。

• Job（任务）：一个完整的执行单元，可以包含多个步骤。

• Step（步骤）：任务中的具体执行操作，比如拉取代码、安装依赖、运行脚本等。

• Runner（运行器）：执行 GitHub Actions 任务的服务器，分为 GitHub 提供的托管 runner 和自托管 runner。

• Event（触发事件）：定义何时运行工作流，例如 push、pull_request、schedule（定时任务）等。

2 解释

工作流文件件存在于你的仓库.github/workflows目录下的*.yml

2.1 示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

name: CI Workflow  # 工作流名称

on: 
  push:            # 触发条件：当代码被推送到仓库时触发
    branches:
      - main       # 仅当推送到 main 分支时触发
  pull_request:    # 触发条件：当有 PR 时触发

jobs:
  test:            # 定义一个名为 "test" 的任务
    runs-on: ubuntu-latest  # 运行环境，使用 GitHub 提供的 Ubuntu 最新版本
    steps:
      - name: Checkout Code   # 第一步：拉取代码
        uses: actions/checkout@v4

      - name: Setup Node.js    # 第二步：设置 Node.js 环境
        uses: actions/setup-node@v4
        with:
          node-version: 18

      - name: Install Dependencies  # 第三步：安装项目依赖
        run: npm install

      - name: Run Tests  # 第四步：执行测试
        run: npm test

3 触发条件

3.1 push（推送触发）

• 示例 1：所有推送都会触发

  1

  on: push

  表示任何 git push 操作都会触发工作流。
• 示例 2：指定分支触发

  1 2 3 4 5

  on: push: branches: - main - dev

  只有当代码推送到 main 或 dev 分支时才会触发。
• 示例 3：指定路径触发

  1 2 3 4 5

  on: push: paths: -'src/**' - '!src/ignore-file.txt'

  只有 src/ 目录下的文件变更时才会触发，但 src/ignore-file.txt 为例外。

3.2 pull_request（拉取请求触发）

• 示例 1：默认触发

  1	on: pull_request

  表示在所有分支上的 PR 操作（opened、synchronize、reopened）都会触发。
• 示例 2：指定分支触发

  1 2 3 4

  on: pull_request: branches: - main

  仅当 PR 目标分支是 main 时触发。
• 示例 3：指定 PR 事件触发

  1 2 3 4 5 6

  on: pull_request: types: - opened # PR 创建时触发 - synchronize # PR 更新时触发（新提交） - reopened # 重新打开 PR 时触发

  可以选择特定 PR 事件来触发工作流。

3.3 workflow_dispatch（手动触发）

• 示例 1：支持手动触发

  1 2	on: workflow_dispatch:

  添加此配置后，可以在 GitHub “Actions” 页面手动运行工作流。
• 示例 2：手动触发并传入参数

  1 2 3 4 5 6 7 8 9 10 11 12

  on: workflow_dispatch: inputs: environment: description: "选择运行环境" required: true default: "production" type: choice options: - development - staging - production

  触发时可以选择 development、staging 或 production 作为运行环境。

3.4 schedule（定时任务触发）

1
2
3
4
5
6
7
8

   cron语法
┌───────── 分钟（0 - 59）
│ ┌────────── 小时（0 - 23）
│ │ ┌─────────── 日期（1 - 31）
│ │ │ ┌──────────── 月份（1 - 12）
│ │ │ │ ┌───────────── 星期（0 - 7，0 和 7 都代表星期天）
│ │ │ │ │
*  *  *  *  * 

• 示例 1：每天凌晨 12 点运行

  1 2 3

  on: schedule: - cron: '0 0 * * *'

  GitHub Actions 服务器使用 UTC 时间，如果需要北京时间（UTC+8），需要调整为 cron: ‘0 16 * * *’。
• 示例 2：每 6 小时运行一次

  1 2 3

  on: schedule: - cron: '0 */6 * * *'

• 示例 3：每周一上午 8 点运行

  1 2 3

  on: schedule: - cron: '0 8 * * 1'

  表示每周一（1 代表周一）北京时间 8:00 运行。

3.5 repository_dispatch（Webhook 事件触发）

• 示例：监听外部 Webhook 事件

  1 2 3

  on: repository_dispatch: types: [custom-event]

  然后使用 GitHub API 触发：

  1 2 3 4

  curl -X POST -H "Authorization: token YOUR_GITHUB_TOKEN" \ -H "Accept: application/vnd.github.v3+json" \ "https://api.github.com/repos/USERNAME/REPO/dispatches" \ -d '{{"event_type": "custom-event"}}'

  这样，你可以从外部应用（如 Jenkins、GitLab CI）触发 GitHub Actions。

3.6 workflow_call（被其他工作流调用）

• 示例：定义可复用的工作流
  在 reusable-workflow.yml 文件中：

  1 2	on: workflow_call:

  在另一个工作流中调用：

  1 2 3

  jobs: call-reusable-workflow: uses: user/repo/.github/workflows/reusable-workflow.yml@main

  这样就可以实现工作流复用。

3.7 push 和 pull_request 组合触发

1
2
3
4
5
6
7

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

这样，当推送到 main 分支或 PR 目标分支为 main 时，工作流都会执行。

3.8 多种触发方式结合

1
2
3
4
5
6
7
8
9
10

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main
  workflow_dispatch:
  schedule:
    - cron: '0 16 * * *'

这表示：

• 当代码推送到 main 分支时触发
• 当 PR 目标分支为 main 时触发
• 可以手动触发
• 每天 UTC 时间 16:00 触发（对应北京时间 00:00）

4 Job的结构

4.1 Job 的完整结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

jobs:
  job_name:             # 任务 ID（唯一标识）
    name: 任务名称       # 任务的可读名称（可选）
    runs-on: 运行环境   # 任务运行的环境
    needs: 依赖任务     # 当前任务需要等待哪些任务完成（可选）
    if: 条件判断        # 任务是否执行的条件（可选）
    outputs:            # 任务的输出变量（可选）
      key: value
    strategy:           # 并行或矩阵策略（可选）
      matrix: ...
    steps:              # 任务中的执行步骤
      - name: 步骤名称
        id: 步骤 ID
        uses: 使用 GitHub 组件
        run: 执行 Shell 命令
        with: 组件的参数
        env: 设定环境变量

4.2 Job 各字段详细说明

4.2.1 job_name（任务 ID）

job_name是 GitHub Actions 内部唯一标识该任务的 ID，不能重复。

• 只能使用小写字母、数字、-或_。

• 不能有空格。

• 这个 ID 可用于依赖（needs）、输出变量（outputs）。

示例

1
2
3
4
5

jobs:
  build_project:   # 任务 ID
    runs-on: ubuntu-latest
    steps:
      - run: echo "运行 build_project"

4.2.2 name（任务名称）

name是任务的可读名称，它会在 GitHub Actions 界面中显示。

• 可以包含空格、大小写、特殊字符。

• 不影响 ID，完全是为了可读性。

示例

1
2
3
4
5
6

jobs:
  build:
    name: 📦 构建项目  # 任务名称
    runs-on: ubuntu-latest
    steps:
      - run: echo "运行 Build 任务"

👉GitHub Actions 界面会显示📦构建项目，但 job ID 仍然是build。

4.2.3 runs-on（运行环境）

指定 job 运行在哪个操作系统或环境上。可以选择：

• GitHub 托管环境：

• ubuntu-latest（默认）

• windows-latest

• macos-latest

• 指定特定版本：

• ubuntu-20.04

• windows-2022

• 自定义 Runner：

• self-hosted

示例

1
2
3
4
5

jobs:
  test:
    runs-on: ubuntu-22.04  # 在 Ubuntu 22.04 运行
    steps:
      - run: echo "运行测试"

4.2.4 needs（依赖任务）

用于让 job 依赖其他 job 的执行结果，必须等前置 job 成功后才运行。

示例

1
2
3
4
5
6
7
8
9
10
11

jobs:
  job1:
    runs-on: ubuntu-latest
    steps:
      - run: echo "Job 1 完成"

  job2:
    needs: job1  # 只有 job1 成功后才会运行
    runs-on: ubuntu-latest
    steps:
      - run: echo "Job 2 开始"

• job1先执行。

• job2依赖job1，等job1成功后才会运行。

4.2.5 if（条件判断）

用于控制 job 是否执行，可以结合状态检查、分支、标签等条件。

示例 1：仅在 main 分支执行

1
2
3
4
5
6

jobs:
  deploy:
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
      - run: echo "仅在 main 分支执行"

示例 2：只有 job1 成功时运行

1
2
3
4
5
6
7
8
9
10
11
12

jobs:
  job1:
    runs-on: ubuntu-latest
    steps:
      - run: exit 0  # 成功

  job2:
    needs: job1
    if: success()  # 只有 job1 成功才执行
    runs-on: ubuntu-latest
    steps:
      - run: echo "Job 1 成功，继续执行 Job 2"

👉其他if关键字：

• success()：前置 job 成功时执行。

• failure()：前置 job 失败时执行。

• always()：无论前置 job 成功或失败都会执行。

4.2.6 outputs（任务输出）

用于让当前 job 生成的值被其他 job 读取。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14

jobs:
  job1:
    runs-on: ubuntu-latest
    outputs:
      message: ${{ steps.step1.outputs.result }}  # 任务的输出
    steps:
      - id: step1
        run: echo "result=hello world" >> $GITHUB_ENV  # 生成变量

  job2:
    needs: job1
    runs-on: ubuntu-latest
    steps:
      - run: echo "Job 1 的输出是 ${{ needs.job1.outputs.message }}"

• job1生成message="hello world"。

• job2读取job1的outputs并打印。

4.2.7 strategy（并行策略）

strategy.matrix可以让 job 在多个环境下同时运行，适用于不同版本测试。

示例

1
2
3
4
5
6
7
8
9
10
11

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-version: [14, 16, 18]  # 在 3 个 Node.js 版本上运行
    steps:
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
      - run: echo "测试 Node.js 版本 ${{ matrix.node-version }}"

👉执行结果：GitHub Actions 会自动创建 3 个任务，分别在 Node.js 14、16 和 18 运行。

4.2.8 steps（任务的执行步骤）

steps是 job 内部的执行单元，每个 step 运行一个命令或 GitHub 组件。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14

jobs:
  my_job:
    runs-on: ubuntu-latest
    steps:
      - name: 拉取代码
        uses: actions/checkout@v4

      - name: 运行 Shell 命令
        run: echo "Hello World!"

      - name: 设置环境变量
        env:
          MY_VAR: "test"
        run: echo "环境变量是 $MY_VAR"

👉steps关键字段：

• name：步骤名称（可选）。

• uses：使用 GitHub 官方组件。

• run：执行 Shell 命令。

• env：设置环境变量。

• with：传递参数给uses。

5 Runs-on相关

5.1 runs-on语法结构

1
2
3
4
5

jobs:
  job_name:
    runs-on: 运行环境
    steps:
      - run: echo "Hello World!"

runs-on指定任务运行的操作系统。可选值包括：ubuntu-latest、windows-latest、macos-latest等。

5.2 GitHub 托管 Runner

GitHub 提供的虚拟机运行 job，无需配置服务器。支持三种操作系统：

操作系统 关键字
Ubuntu（默认） ubuntu-latest
Windows windows-latest
macOS macos-latest

5.2.1 Ubuntu

Ubuntu 是默认 Runner，启动最快，支持最多工具。

1

runs-on: ubuntu-latest

可选版本：

• ubuntu-22.04

• ubuntu-20.04（推荐）

• ubuntu-18.04（即将废弃）

示例

1
2
3
4
5

jobs:
  test:
    runs-on: ubuntu-20.04
    steps:
      - run: echo "运行 Ubuntu 20.04"

5.2.2 Windows

适用于 Windows 相关的构建和测试。

1

runs-on: windows-latest

可选版本：

• windows-2022

• windows-2019（推荐）

示例

1
2
3
4
5

jobs:
  test:
    runs-on: windows-2019
    steps:
      - run: echo "Windows 任务"

5.2.3 macOS

适用于 macOS/iOS 开发，如 Xcode、Swift。

1

runs-on: macos-latest

可选版本：

• macos-14

• macos-13

• macos-12（推荐）

示例

1
2
3
4
5

jobs:
  test:
    runs-on: macos-12
    steps:
      - run: echo "Mac 任务"

5.2.4 自托管 Runner

如果官方 Runner 不满足需求（如 ARM 设备、私有服务器），可以自建 Runner。

1

runs-on: self-hosted

可以加标签：

1

runs-on: [self-hosted, linux, arm64]

示例

1
2
3
4
5

jobs:
  my_job:
    runs-on: [self-hosted, ubuntu, gpu]
    steps:
      - run: echo "自托管 Runner"

👉适用场景：

• 运行 ARM 设备（如树莓派）

• 需要访问私有网络资源

• 需要更强的硬件性能

5.3 组合多个runs-on

5.3.1 标签实现多个runs-on

可以同时指定多个标签，让 job 运行在符合所有条件的 Runner 上。

示例

1

runs-on: [self-hosted, ubuntu, docker]

仅在自托管且 Ubuntu 并支持 Docker 的 Runner 上执行。

5.3.2 runs-on动态选择（矩阵matrix）

可以使用矩阵strategy.matrix在不同环境同时运行 job。

示例

1
2
3
4
5
6
7
8

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - run: echo "运行在 ${{ matrix.os }}"

👉这个 job 会自动运行 3 次，分别在：

1. ubuntu-latest

2. windows-latest

3. macos-latest

5.4 runs-on的完整示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

jobs:
  job1:
    runs-on: ubuntu-latest
    steps:
      - run: echo "运行在 Ubuntu"

  job2:
    runs-on: windows-2019
    steps:
      - run: echo "运行在 Windows"

  job3:
    runs-on: macos-12
    steps:
      - run: echo "运行在 macOS"

  job4:
    runs-on: [self-hosted, gpu]
    steps:
      - run: echo "运行在自托管 GPU 服务器"

6 steps

6.1 steps语法结构

1
2
3
4
5
6
7
8
9
10
11

jobs:
  job_name:
    runs-on: ubuntu-latest
    steps:
      - name: 步骤名称（可选）
        id: 步骤 ID（可选）
        uses: GitHub 组件（可选）
        run: 执行 Shell 命令（可选）
        with: 传递参数（仅用于 `uses`）
        env: 设定环境变量（可选）
        if: 条件判断（可选）

• name：步骤名称，在 GitHub Actions UI 显示。

• id：步骤唯一标识，用于引用该步骤的输出。

• uses：使用 GitHub 官方/社区组件。

• run：执行 Shell 命令（如果不使用uses）。

• with：传递参数给uses。

• env：环境变量。

• if：设置步骤执行条件。

6.2 steps关键字段解析

6.2.1 name（步骤名称）

name是 GitHub Actions UI 中的步骤名称，用于标记当前步骤的作用。

示例

1
2
3

steps:
  - name: 🚀 运行 Shell 命令
    run: echo "Hello, GitHub Actions!"

👉运行效果：

1
2

🚀 运行 Shell 命令
Hello, GitHub Actions!

❗注意：name只是 UI 显示，不影响步骤执行。

6.2.2 id（步骤 ID）

id用于在当前job内唯一标识某个步骤，可以让后续步骤读取它的输出。

示例

1
2
3
4
5
6
7

steps:
  - name: 计算时间
    id: time_step
    run: echo "time=$(date +%s)" >> $GITHUB_ENV

  - name: 读取时间
    run: echo "时间戳是 ${{ env.time }}"

👉解析：

• id: time_step标记该步骤。

• echo "time=$(date +%s)" >> $GITHUB_ENV保存输出变量。

• run: echo "时间戳是 ${{ env.time }}"读取前一个步骤的变量。

6.2.3 uses（使用 GitHub 组件）

GitHub Actions 允许直接使用社区组件，避免重复造轮子。

组件来源：

• GitHub 官方：actions/checkout@v4

• 第三方社区：actions/setup-node@v4

示例 1：使用checkout组件拉取代码

1
2
3

steps:
  - name: 拉取代码
    uses: actions/checkout@v4

示例 2：使用setup-node组件安装 Node.js

1
2
3
4
5

steps:
  - name: 安装 Node.js 16
    uses: actions/setup-node@v4
    with:
      node-version: 16

👉解析：

• uses: actions/setup-node@v4使用官方setup-node组件。

• with.node-version: 16安装 Node.js 16。

6.2.4 run（运行 Shell 命令）

run直接执行 Shell 命令，支持 Linux（Bash）、Windows（PowerShell）。

示例 1：单行命令

1
2
3

steps:
  - name: 运行 Bash 命令
    run: echo "Hello, GitHub Actions!"

示例 2：多行命令

1
2
3
4
5
6

steps:
  - name: 多行 Shell 命令
    run: |
      echo "第一行"
      echo "第二行"
      echo "第三行"

示例 3：Windows 执行 PowerShell

1
2
3
4

steps:
  - name: 运行 PowerShell
    run: Write-Output "Hello, Windows!"
    shell: pwsh

6.2.5 with（传递参数）

用于给uses组件传递参数，不同的组件with参数不同。

示例 1：使用setup-node安装 Node.js

1
2
3
4
5

steps:
  - name: 使用 `setup-node` 安装 Node.js
    uses: actions/setup-node@v4
    with:
      node-version: 18

👉解析：

• with.node-version: 18指定安装 Node.js 18。

示例 2：上传文件

1
2
3
4
5
6

steps:
  - name: 上传文件
    uses: actions/upload-artifact@v3
    with:
      name: my-artifact
      path: ./output

• with.name指定上传的文件名称。

• with.path指定上传的文件夹路径。

6.2.6 env（环境变量）

用于设置步骤的环境变量，可以让run读取。

示例 1：自定义环境变量

1
2
3
4
5

steps:
  - name: 设置环境变量
    env:
      GREETING: "Hello"
    run: echo "$GREETING, GitHub Actions!"

👉解析：

• env.GREETING: "Hello"定义变量。

• echo "$GREETING, GitHub Actions!"使用变量。

示例 2：使用 GitHub 内置环境变量

1
2
3

steps:
  - name: 显示 GitHub 仓库信息
    run: echo "当前仓库：${{ github.repository }}"

GitHub 提供了内置变量，如：

• ${{ github.repository }}：当前仓库名。

• ${{ github.ref }}：当前分支。

• ${{ github.actor }}：触发者。

6.2.7 if（条件执行）

if用于控制步骤是否执行，支持：

• 成功时执行：if: success()

• 失败时执行：if: failure()

• 始终执行：if: always()

• 按分支执行：if: github.ref == 'refs/heads/main'

示例 1：仅在 main 分支执行

1
2
3
4

steps:
  - name: 仅在 main 分支执行
    if: github.ref == 'refs/heads/main'
    run: echo "当前是 main 分支"

示例 2：前面步骤失败时执行

1
2
3
4
5
6
7

steps:
  - name: 运行失败的命令
    run: exit 1

  - name: 失败时运行
    if: failure()
    run: echo "上一步失败了！"

6.3 steps组合示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

jobs:
  my_job:
    runs-on: ubuntu-latest
    steps:
      - name: 拉取代码
        uses: actions/checkout@v4

      - name: 设置环境变量
        env:
          MY_VAR: "Hello"
        run: echo "$MY_VAR, GitHub Actions!"

      - name: 安装 Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 18

      - name: 运行 npm 脚本
        run: npm install && npm test

      - name: 仅在 main 分支执行部署
        if: github.ref == 'refs/heads/main'
        run: echo "部署到生产环境"

GitHub Actions 中的strategy详解

strategy用于控制job的执行方式，可以用于：

• 并行执行多个任务（矩阵matrix）

• 重试失败的任务（fail-fast和max-parallel）

7 strategy相关

7.1 strategy语法结构

1
2
3
4
5
6
7
8
9
10

jobs:
  job_name:
    runs-on: ubuntu-latest
    strategy:
      matrix: # 定义矩阵
        变量名称: [值1, 值2, 值3]
      fail-fast: true  # 其中一个失败，全部取消
      max-parallel: 2  # 最多同时运行 2 个任务
    steps:
      - run: echo "Hello World"

7.2 matrix（矩阵构建）

matrix允许并行运行多个job，每个job使用不同的参数组合。

示例 1：在不同操作系统运行

1
2
3
4
5
6
7
8

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - run: echo "当前系统是 ${{ matrix.os }}"

👉这个job会自动运行 3 次：

1. ubuntu-latest

2. windows-latest

3. macos-latest

示例 2：在不同 Node.js 版本运行

1
2
3
4
5
6
7
8
9
10
11
12

jobs:
  test:
    strategy:
      matrix:
        node: [14, 16, 18]
    runs-on: ubuntu-latest
    steps:
      - name: 设置 Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
      - run: node -v

👉这个job会运行 3 次：

• 使用 Node.js 14

• 使用 Node.js 16

• 使用 Node.js 18

7.3 组合多个matrix变量

可以组合多个变量，GitHub Actions 会自动生成所有可能的组合。

示例

1
2
3
4
5
6
7
8
9

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]
        node: [14, 16]
    runs-on: ${{ matrix.os }}
    steps:
      - run: echo "系统: ${{ matrix.os }}, Node.js 版本: ${{ matrix.node }}"

👉自动生成 4 组job：

7.4 exclude（排除某些组合）

有时不需要所有组合，可以排除一些组合。

示例

1
2
3
4
5
6
7
8
9
10
11
12

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]
        node: [14, 16]
      exclude:
        - os: windows-latest
          node: 14  # 排除 Windows + Node 14
    runs-on: ${{ matrix.os }}
    steps:
      - run: echo "系统: ${{ matrix.os }}, Node.js 版本: ${{ matrix.node }}"

👉只运行 3 组job：

7.5 include（添加额外组合）

可以手动添加额外的matrix组合。

示例

1
2
3
4
5
6
7
8
9
10
11
12

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]
        node: [14, 16]
      include:
        - os: ubuntu-latest
          node: 18  # 额外增加 Ubuntu + Node 18
    runs-on: ${{ matrix.os }}
    steps:
      - run: echo "系统: ${{ matrix.os }}, Node.js 版本: ${{ matrix.node }}"

👉生成 5 组job：

7.6 fail-fast（任务失败时是否取消）

fail-fast: true（默认）：如果有一个job失败，取消所有剩余任务

fail-fast: false：即使有任务失败，其他job仍然运行

示例

1
2
3
4
5
6
7
8
9

jobs:
  test:
    strategy:
      fail-fast: false  # 允许所有任务运行完
      matrix:
        os: [ubuntu-latest, windows-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - run: exit 1  # 故意让任务失败

👉fail-fast: false时，失败的任务不影响其他任务。

7.7 max-parallel（最大并行任务数）

默认：GitHub Actions 会并行执行所有matrix任务

可以限制最大并行任务数

示例

1
2
3
4
5
6
7
8
9

jobs:
  test:
    strategy:
      max-parallel: 2  # 同时最多运行 2 个任务
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - run: echo "当前系统: ${{ matrix.os }}"

👉3 个任务会最多 2 个同时运行，1 个等待。

7.8 strategy组合示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]
        node: [14, 16, 18]
      exclude:
        - os: windows-latest
          node: 14  # 排除 Windows + Node 14
      include:
        - os: ubuntu-latest
          node: 20  # 额外增加 Ubuntu + Node 20
      fail-fast: false  # 任务失败时继续执行
      max-parallel: 2  # 最多同时运行 2 个任务
    runs-on: ${{ matrix.os }}
    steps:
      - name: 安装 Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
      - run: node -v

👉执行的任务：

8 env 变量

8.1 env变量的三种作用域

env变量可以在以下三种层级定义：

1. 工作流级别（workflow）：适用于整个.yml文件

2. 任务级别（job）：适用于 job 内所有 steps

3. 步骤级别（step）：仅适用于单个 step

8.2 env语法结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

name: 示例工作流
on: push

env: # ✅ 工作流级变量（全局）
  GLOBAL_VAR: "全局变量"

jobs:
  my_job:
    runs-on: ubuntu-latest
    env: # ✅ `job` 级变量（适用于 `my_job`）
      JOB_VAR: "任务变量"
    steps:
      - name: 显示全局变量
        run: echo "$GLOBAL_VAR"

      - name: 显示任务变量
        run: echo "$JOB_VAR"

      - name: 设置步骤变量
        env: # ✅ `step` 级变量（仅适用于本 `step`）
          STEP_VAR: "步骤变量"
        run: echo "$STEP_VAR"

执行结果：

1
2
3

全局变量
任务变量
步骤变量

8.3 env变量的作用范围

8.4 使用env变量

8.4.1 读取环境变量

在run里使用不同的 Shell 读取env变量：

示例：

1
2
3
4
5
6
7
8
9
10
11

jobs:
  example:
    runs-on: ubuntu-latest
    env:
      MESSAGE: "Hello from job"
    steps:
      - name: 读取环境变量（Linux/macOS）
        run: echo "$MESSAGE"
      - name: 读取环境变量（Windows）
        run: Write-Output $env:MESSAGE
        shell: pwsh

输出：

1
2

Hello from job
Hello from job

8.4.2 组合多个变量

示例：

1
2
3
4
5
6
7
8
9

jobs:
  example:
    runs-on: ubuntu-latest
    env:
      USER_NAME: "Alice"
      GREETING: "Hello"
    steps:
      - name: 使用多个变量
        run: echo "$GREETING, $USER_NAME!"

输出：

1

Hello, Alice!

8.5 env变量的高级用法

8.5.1 GITHUB_ENV（动态设置env变量）

可以在run中动态创建env变量。

示例：

1
2
3
4
5
6
7
8

jobs:
  example:
    runs-on: ubuntu-latest
    steps:
      - name: 设置环境变量
        run: echo "MY_VAR=动态变量" >> $GITHUB_ENV
      - name: 读取环境变量
        run: echo "$MY_VAR"

输出：

1

动态变量

8.5.2 读取 GitHub 内置环境变量

GitHub 提供了许多内置变量，可以直接在env里使用。

示例：

1
2
3
4
5
6

jobs:
  example:
    runs-on: ubuntu-latest
    steps:
      - name: 显示 GitHub 内置变量
        run: echo "当前仓库: ${{ github.repository }}"

可能输出：

1

当前仓库: my-user/my-repo

常见 GitHub 内置变量：

8.5.3 secrets（私密变量）

secrets用于存储敏感数据（如 API 密钥），不会暴露在日志里。

示例：

1
2
3
4
5
6

jobs:
  example:
    runs-on: ubuntu-latest
    steps:
      - name: 读取 GitHub 密钥
        run: echo "TOKEN = ${{ secrets.MY_SECRET }}"

如何添加secrets：

1. 进入 GitHub 仓库Settings

2. 打开Secrets and variables→选择Actions

3. 点击New repository secret

4. 添加MY_SECRET，值为my_secret_value

8.5.4 env变量 vssecrets

####8.6 env变量的常见问题

❓1.为什么env变量在run里无效？

正确写法：

1
2
3
4
5

steps:
  - name: 读取 `env`
    env:
      MESSAGE: "Hello"
    run: echo "$MESSAGE"

错误写法：

1
2
3

steps:
  - name: 变量未定义
    run: echo "$MESSAGE"  # 变量未在 `env` 定义

修正：

1
2
3
4
5

steps:
  - name: 先定义变量
    run: echo "MESSAGE=Hello" >> $GITHUB_ENV
  - name: 读取变量
    run: echo "$MESSAGE"

❓2.secrets变量为什么在日志里不显示？

GitHub 自动隐藏secrets变量，即使你echo也不会显示。

示例：

1
2
3
4
5
6

jobs:
  example:
    runs-on: ubuntu-latest
    steps:
      - name: 读取密钥
        run: echo "TOKEN=${{ secrets.MY_SECRET }}"

错误输出：

1

TOKEN=***

正确输出：

1

TOKEN=your_actual_secret_value  （但不会显示在 GitHub UI）

9 uses语法

uses语法过多自行访问GitHub Marketplace查找

官方文档

更具体的请看官方文档吧！如果上面内容有有错误欢迎指出！

• GitHub Actions 文档

这边以Android的企业微信为例，打开企业微信登录 。点击底部消息 -> 右上角+号 -> 发起群聊 -> 选择人创建并打开群聊 -> 点击三个点 -> 群机器人 -> 创建就能看到了。
其他平台的都一样的，就是只能是企业群聊才可以，外部群聊不行。

添加成功后，系统会生成一个 Webhook URL，格式如下：

1

https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=your_key

二、发送消息

企业微信 Webhook 支持多种消息类型，包括文本、Markdown、图片、文件等。以下以发送文本消息为例。

1. 文本消息格式

• 请求方式：POST
• 请求头：Content-Type: application/json
• 请求体示例：

  1 2 3 4 5 6

  { "msgtype": "text", "text": { "content": "这是一条测试消息" } }

2. 使用 cURL 发送消息

• 在终端中运行以下命令：

  1 2 3 4 5 6 7 8

  curl 'https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=your_key' \ -H 'Content-Type: application/json' \ -d '{ "msgtype": "text", "text": { "content": "这是一条测试消息" } }'

3. 使用 Python 发送消息

• 安装 requests 库（如果尚未安装）：

  1	pip install requests

• 编写 Python 脚本：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  import requests import json webhook_url = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=your_key" headers = {"Content-Type": "application/json"} data = { "msgtype": "text", "text": { "content": "这是一条测试消息" } } response = requests.post(webhook_url, headers=headers, data=json.dumps(data)) print(response.status_code, response.text)

三、支持的消息类型

除了文本消息，企业微信 Webhook 还支持以下消息类型：

1. Markdown 消息

   • 请求体示例：

     1 2 3 4 5 6

     { "msgtype": "markdown", "markdown": { "content": "**加粗文字**\n> 引用内容" } }

2. 图片消息

• 请求头实例:

  1 2 3 4 5 6 7

  { "msgtype": "image", "image": { "base64": "DATA", "md5": "MD5" } }

  base64是图片内容的base64编码
  md5是图片内容（base64编码前）的md5值

注：图片（base64编码前）最大不能超过2M，支持JPG,PNG格式

3. 文件消息

   • 通过下文的上传文件接口获取 media_id，然后发送：

     1 2 3 4 5 6

     { "msgtype": "file", "file": { "media_id": "your_media_id" } }

4. 图文消息

   • 请求体示例：

     1 2 3 4 5 6 7 8 9 10 11 12 13

     { "msgtype": "news", "news": { "articles": [ { "title": "标题", "description": "描述", "url": "https://example.com", "picurl": "https://example.com/image.png" } ] } }

只提供部分实例，具体请参考 群机器人配置说明

四、注意事项

1. 消息频率限制

   • 每个 Webhook URL 每分钟最多发送 20 条消息，超过限制会被暂时禁用。

2. 安全性

   • Webhook URL 包含密钥，请勿泄露。如果泄露，可以在企业微信管理后台重新生成。

3. 错误处理

   • 如果发送失败，检查返回的状态码和错误信息：
     • 400：请求参数错误。
     • 404：Webhook URL 无效。
     • 429：消息发送频率过高。

五、总结

通过企业微信 Webhook，开发者可以轻松实现消息推送功能。无论是监控报警、任务通知，还是自动化流程，Webhook 都提供了简单高效的解决方案。

如果你有更多问题或需要进一步的帮助，请参考 企业微信官方文档 或留言讨论。

在application.yml写

1
2
3
4

spring:
  mvc:
    pathmatch:
      matching-strategy: ant_path_matcher

或者在application.properties写

1

spring.mvc.pathmatch.matching-strategy=ant_path_matcher

方法二：
在启动类Application加上

1
2
3
4
5
6

@Bean
    HttpFirewall httpFirewall() {
        StrictHttpFirewall firewall = new StrictHttpFirewall();
        firewall.setAllowUrlEncodedDoubleSlash(true);
        return firewall;
    }

原因很简单，Spring Boot干掉了双斜杠。

刚开始使用Termux的时候可能会出现:

1
2

$ curl
CANNOT LINK EXECUTABLE "curl": library "libssl.so.1.1" not found: needed by /data/data/com.termux/files/usr/lib/libssh2.so in namespace (default)

解决方案就是:

1

pkg update

近日，我在编辑一张动态图片时，意外发现了一段有趣的元数据。这段数据不仅揭示了图片拍摄时的信息，还隐藏了一个关于视频的秘密。

在深入探索这张图片的元数据时，我注意到了GCamera:MicroVideoOffset这一字段。经过研究，我了解到这个字段代表的是视频偏移量，意味着在这个地址之后，隐藏着视频数据。

具体来说，这张动态图片实际上包含了一个微视频。通过解析GCamera:MicroVideoOffset所指示的位置，我们可以直接截取到这段视频。

以下是部分元数据的展示（已省略部分内容以节省篇幅）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

...
<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.1.0-jc003">
  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
    <rdf:Description rdf:about=""
        xmlns:GCamera="http://ns.google.com/photos/1.0/camera/"
        xmlns:MiCamera="http://ns.phone.com/photos/1.0/camera/"
      GCamera:MicroVideoVersion="1"
      GCamera:MicroVideo="1"
      GCamera:MicroVideoOffset="2013388"
      GCamera:MicroVideoPresentationTimestampUs="722627"
      MiCamera:XMPMeta="&lt;?xml version='1.0' encoding='UTF-8' standalone='yes' ?&gt;"/>
  </rdf:RDF>
</x:xmpmeta>
...

从上面的元数据可以看出，GCamera:MicroVideoOffset的值为“2013388”，这表示视频数据位于该偏移量之后。

验证猜想

为了验证这一发现，我尝试使用tail命令来提取视频。虽然tail命令通常用于查看文件的末尾部分，但在这里，我们可以通过指定偏移量和字节数来截取包含视频数据的部分。

我们可以使用以下命令来提取视频：

1

tail -c +2013388 动态图片文件 > 提取的视频文件

然而，需要注意的是，这里的“+2013388”表示从文件的第2013388个字节开始提取。

结果，提取的那个视频正好可以播放。

Fish（Friendly Interactive SHell）凭借其友好的用户界面和简洁的语法，也逐渐赢得了不少用户的青睐。然而，Fish在环境变量设置方式上的独特之处，可能会给一些程序带来运行上的困扰。

Fish环境变量设置的独特性

与其他Shell相比，Fish在环境变量设置方面有着显著的不同。在Fish中，set命令被用于设置变量，但赋值时并不使用等号（=），而是通过空格直接分隔变量名和值。例如，要设置一个名为MY_VAR的变量，并赋值为hello，在Fish中应使用以下命令：

1

set MY_VAR hello

而在Bash等Shell中，相同的操作则使用等号进行赋值，如下所示：

1

export MY_VAR=hello

正是这种差异导致了Fish环境变量设置方式与其他Shell有所不同，这可能导致一些程序在Fish中运行时找不到所需的路径或变量。

程序兼容性问题

脚本兼容性问题：一些程序可能通过脚本（如Bash脚本）来执行特定的任务。如果这些脚本是为其他Shell编写的，并且包含了对特定Shell命令或特性的依赖，那么当它们在Fish中运行时，可能会因为不兼容而导致错误。

解决方案

针对上述问题，以下是一些可能的解决方案：

1. 修改脚本以适应Fish：如果程序是通过脚本运行的，并且脚本中存在对其他Shell的依赖，那么可以尝试修改脚本，使其兼容Fish。这通常涉及到替换特定的Shell命令或语法。

2. 在Fish中设置正确的环境变量和路径：确保在Fish中正确设置了程序所需的所有环境变量和路径。这可以通过手动设置变量或使用Fish的配置文件（如config.fish）来实现。

3. 使用其他Shell运行程序：如果修改脚本或设置环境变量不可行，或者程序对Shell的依赖过于复杂，那么可以考虑使用其他Shell（如Bash或Zsh）来运行程序。这可以通过在Fish中调用其他Shell的命令行界面来实现。

在使用 SSH 远程连接服务器时，经常会遇到网络不稳定或长时间无操作导致连接中断的情况。这不仅会影响工作效率，还可能导致未保存的工作丢失。为了解决这个问题，我们可以使用 tmux，一个强大的终端复用工具。

1. 什么是 Tmux？

tmux 是一个终端复用工具，允许用户在一个终端窗口中创建多个会话、窗口和面板。它的核心功能包括：

• 会话管理：可以在一个终端中创建多个会话，并在这些会话之间自由切换。
• 窗口和面板：每个会话可以包含多个窗口，每个窗口又可以分割成多个面板。
• 断线重连：即使 SSH 连接中断，tmux 会话仍然会保留在服务器上，重新连接后可以恢复工作状态。

正是这些特性，使得 tmux 成为解决 SSH 自动断连问题的利器。

2. 安装 Tmux

在大多数 Linux 发行版中，tmux 可以通过包管理器直接安装。

• Debian/Ubuntu:

  1	sudo apt install tmux

• CentOS/RHEL:

  1	sudo yum install tmux

• macOS:

  1	brew install tmux

安装完成后，可以通过 tmux -V 检查是否安装成功。

3. 基本使用

启动 Tmux 会话

在终端中输入以下命令启动一个新的 tmux 会话：

1

tmux

这会创建一个新的会话，并进入一个全新的终端环境。

命名会话

为了方便管理，可以为会话命名后再启动：

1

tmux new -s mysession

其中 mysession 是你为会话指定的名称。

分离会话

在 tmux 会话中，按下 Ctrl + b，然后按 d，可以分离当前会话。此时会话会在后台继续运行，即使 SSH 断开也不会影响。

重新连接会话

重新连接 SSH 后，可以通过以下命令重新连接到之前的会话：

1

tmux attach -t mysession

其中 mysession 是你要恢复的会话名称。

查看所有会话

如果想查看当前所有的 tmux 会话，可以使用：

1

tmux ls

4. 解决 SSH 自动断连问题

tmux 的核心优势在于它的会话持久化功能。以下是具体的使用场景：

1. 启动 Tmux 会话
   在 SSH 连接到服务器后，立即启动一个 tmux 会话：

   1	tmux new -s work

2. 在 Tmux 中工作
   在 tmux 会话中运行你的任务，例如编辑文件、运行脚本等。

3. 网络中断或 SSH 断开
   如果网络不稳定或 SSH 连接中断，tmux 会话仍然会在服务器上运行。

4. 重新连接并恢复工作
   重新 SSH 连接到服务器后，使用以下命令恢复之前的会话：

   1	tmux attach -t work

   你会发现所有的工作状态都完好无损。

5. 常用 Tmux 快捷键

以下是一些常用的 tmux 快捷键（默认前缀键为 Ctrl + b）：

• 创建新窗口：Ctrl + b, c
• 切换窗口：Ctrl + b, 窗口编号（例如 Ctrl + b, 0 切换到第一个窗口）
• 水平分割面板：Ctrl + b, "
• 垂直分割面板：Ctrl + b, %
• 切换面板：Ctrl + b, 方向键（例如 Ctrl + b, → 切换到右侧面板）
• 关闭面板：Ctrl + b, x
• 列出所有会话：Ctrl + b, s
• 重命名当前会话：Ctrl + b, $

6. 高级技巧

自动启动 Tmux

如果你希望每次 SSH 登录时自动启动或恢复 tmux 会话，可以将以下代码添加到 ~/.bashrc 或 ~/.zshrc 中：

1
2
3

if [[ -z "$TMUX" ]] && [[ -n "$SSH_CONNECTION" ]]; then
  tmux attach -t ssh || tmux new -s ssh
fi

这样，每次 SSH 登录时，tmux 会自动恢复名为 ssh 的会话，或者创建一个新的会话。

配置文件

tmux 支持通过配置文件（~/.tmux.conf）自定义行为。例如，可以修改前缀键、启用鼠标支持等。以下是一个简单的配置示例：

1
2
3
4
5
6
7
8
9
10
11

# 将前缀键改为 Ctrl + a
unbind C-b
set-option -g prefix C-a
bind C-a send-prefix

# 启用鼠标支持
set -g mouse on

# 设置状态栏颜色
set -g status-bg blue
set -g status-fg white

7. 总结

通过使用 tmux，你可以轻松解决 SSH 自动断连的问题，同时提高终端操作的效率。无论是长时间运行的任务，还是多任务并行处理，tmux 都能为你提供一个稳定、灵活的工作环境。

如果你还没有尝试过 tmux，不妨从今天开始使用它，体验它带来的便利吧！

在使用 Hexo 生成静态博客并发布到远程服务器时，rsync 是一个非常高效的工具。然而，在 Windows 环境下使用 rsync 可能会遇到一些问题。

错误：'rsync' �����ڲ����ⲿ���Ҳ���ǿ����еij���

这个错误通常是因为系统找不到 rsync 可执行文件。解决方法如下：

1. 检查环境变量
   确保 rsync 的路径已经添加到系统的 PATH 环境变量中。

2. 使用绝对路径
   如果你使用的是 cwRsync，可以在 Hexo 的 _config.yml 中使用绝对路径来指定 rsync 的位置。例如：

   1 2 3 4 5 6 7 8 9

   deploy: type: rsync rsync: "C:/Program Files/cwRsync/bin/rsync.exe" host: your.server.com user: your_username root: /path/to/your/blog port: 22 delete: true verbose: true

1. 安装 Rsync

在 Windows 上，rsync 并不是原生支持的，因此我们需要借助第三方工具来实现。使用 cwRsync。

使用 cwRsync

1. 下载 cwRsync
   访问 cwRsync 官网，下载并安装适合你系统的版本。

2. 配置环境变量
   安装完成后，将 cwRsync 的安装路径（例如 C:\Program Files\cwRsync\bin）添加到系统的环境变量 PATH 中。

3. 验证安装
   打开命令提示符（CMD），输入 rsync --version，如果能看到版本信息，说明安装成功。

2. 配置 Hexo 使用 Rsync

在 Hexo 的配置文件 _config.yml 中，找到 deploy 部分，添加或修改如下配置：

1
2
3
4
5
6
7
8

deploy:
  type: rsync
  host: your.server.com
  user: your_username
  root: /path/to/your/blog
  port: 22
  delete: true
  verbose: true

• host: 你的服务器地址。
• user: 登录服务器的用户名。
• root: 服务器上存放博客的路径。
• port: SSH 端口，默认为 22。
• delete: 是否删除服务器上多余的文件，建议设置为 true。
• verbose: 是否显示详细日志，建议设置为 true 以便调试。

4. 测试发布

完成配置后，运行以下命令来发布你的博客：

1

hexo clean && hexo deploy --generate

如果一切顺利，你应该能够看到 rsync 开始同步文件，并且博客成功发布到远程服务器。

如果你还有其他问题，欢迎在评论区留言讨论

您在使用 GnuPG (GPG) 生成密钥时遇到了以下错误。

1
2

gpg: agent_genkey failed: No pinentry
Key generation failed: No pinentry

这个错误通常是由于 pinentry 程序未正确安装或配置导致的。pinentry 是一个用于处理密码输入的辅助程序，GPG 需要它来安全地提示用户输入密码。

解决此问题：

1. 安装 pinentry

首先，确保您的系统中已安装 pinentry。根据您使用的操作系统，安装方法可能有所不同：

Debian/Ubuntu:

1
2

sudo apt-get update
sudo apt-get install pinentry

Fedora:

1

dnf install pinentry

Arch Linux:

1

pacman -S pinentry

macOS (使用 Homebrew):

1

brew install pinentry

2. 重新使用GPG生成

如果还是没用，可以尝试重启一遍终端

JetBrains 全家桶激活（2024最新）.zip | AList

开始激活

1. 首先先退出你的IDE

2. 进入到解压后的文件夹 /win2020-2024(一键激活) 中，双击 IDEA激活.vbs（按需选择） ，若提示 Success!!! Now you can enjoy IntelliJIdea to 2099 , 则表示你的 IDE 激活成功啦~

启动

启动你的IDE即可。

免责声明

本教程IDE破解补丁、激活码均收集于网络，请勿商用，仅供个人学习使用，如有侵权，请联系作者删除。若条件允许，希望大家购买正版 ！本工具不鼓励盗版，对于不正确的使用，请自行承担责任。如果你使用本工具，则表示你自动同意上述书面协议，因此，任何责任和后果请自负。

提示：

本内容转载自犬小哈，本工具非我编写，请自行辨认！

开源 Windows 和 Office 激活器，具有 HWID、Ohook、KMS38 和在线 KMS 激活方法，以及高级故障排除。

下载 / 如何使用它？

方法 1 - PowerShell（Windows 8 及更高版本） ❤️

1. 打开 PowerShell（不是 CMD）。为此，请右键单击 Windows 开始菜单并选择 PowerShell 或终端。
2. 复制并粘贴下面的代码，然后按 Enter 键

1

irm https://get.activated.win | iex

3. 您将看到激活选项。

   （1） HWID： 进行 Windows 激活。

   （2） Ohook ：给 Office 激活。

   …如图

   

4. 就这样。

或者您可以使用以下内容（将来将弃用）。

1

irm https://massgrave.dev/get | iex

该 URL 可能被某些 DNS 服务阻止，因为它是一个新域。get.activated.win

方法 2 - 传统（Windows 7 及更高版本）

1. 使用下面提供的链接下载文件。

• https://github.com/massgravel/Microsoft-Activation-Scripts/archive/refs/heads/master.zip 或者
• https://git.activated.win/massgrave/Microsoft-Activation-Scripts/archive/master.zip

3. 右键单击下载的 zip 文件并解压缩在解压缩的文件夹中，找到名为All-In-One-Version运行名为MAS_AIO.cmd您将看到激活选项，请按照屏幕上的说明进行操作。就这样。

注意：

• PowerShell 中的 IRM 命令从指定的 URL 下载脚本，然后 IEX 命令执行该脚本。
• 在执行命令之前，请务必仔细检查 URL，如果手动下载文件，请验证来源。
• 请谨慎，因为有些应用程序通过在 IRM 命令中使用不同的 URL 来传播伪装成 MAS 的恶意软件。

方法二：使用传统桌面工具（容易报毒）

HEU KMS Activator中文版是一款简洁高效的KMS/OEM智能激活工具，适用所有Windows、Office版本，无需联网即可一键激活，支持UEFI的KMS激活工具。KMS服务是微软对Windows、Office等产品的批量许可服务，利用KMS可以激活局域网内的产品。该工具利用KMS机制在系统搭建KMS服务器，从而实现在线或离线激活。

下载

点击下载安装 HEU_KMS_Activator

如何使用它？

功能简介

1、智能激活：智能识别最佳的激活方式
优先顺序依次为数字许可证/KMS38/OEM/KMS
自动识别并跳过已经永久激活的Windows/Office

2、KMS激活
安装/卸载自动续期功能，两种模式可供选择[1]自动续订模式(默认 [2]任务计划模式
清除KMS客户端信息：清除KMS服务器地址、端口、激活时间间隔、续订时间间隔等
搭建KMS服务器[手动激活]：KMS服务器地址/端口

3、数字激活（数字许可证激活、KMS38激活）
添加/解除KMS38保护，免受180天激活影响，除非解除保护，否则不能使用KMS38激活
查看当前系统信息：网络状态/激活状态，描述便于快速查看是否支持数字许可证/KMS38

4、OEM激活（提供6种模式）
卸载OEM激活信息：清除动态加载的SLIC等信息，OEM激活将失效
生产$OEM$文件夹：可将该文件夹置于ISO镜像source文件夹下，以集成OEM激活功能

5、更改Windows 10版本、激活信息备份还原、Microsoft Office 零售版转换批量授权版

6、Windows/Office密钥管理功能：安装密钥、卸载密钥、查看密钥、清除Office许可证

7、智能激活、激活成功率高、支持静默参数、几乎支持所有 Windows/Office 所有版本

8、Windows 7上无需依赖.NET Framework、能够离线激活，也能连接网络服务器激活

静默参数

/? 查看静默参数
/smart 智能激活
/dig 数字许可证激活Win10/11
/k38 激活Win10/11至2038年
/lok 添加KMS38保护
/oem OEM激活Win Vista/7/Server
/od1 OEM模式1(默认)
/od2 OEM模式2
/kwi 使用KMS激活Windows
/kof 使用KMS激活Office
/kd1 KMS模式1(默认)
/kd2 KMS模式2
/wxp 激活Windows XP
/r2v Office R2V
/ren 安装自动续期功能
/unr 卸载自动续期功能
/reb 重启计算机
/nologo 使用静默参数时不显示logo

无人值守静默方式以数字许可永久激活系统：

1

HEU_KMS_Activator.exe /kwi /dig /nologo

注意：此激活工具Microsoft Defender会误报威胁，记得加排除!

免责声明

本软件完全免费，仅供研究激活原理测试使用，任何个人和组织不得以任何形式进行出售，任何商业行为与我本人没有任何关系，并非我的本意。如果你想使用Windows或Office，请前往微软正规渠道购买正版授权。本程序不鼓励盗版，对于不正确的使用，请自行承担责任。如果你使用本程序，则表示你自动同意上述书面协议，因此，任何责任和后果请自负。

动画图解、一键运行的数据结构与算法教程

• 代码仓库 > https://github.com/krahets/hello-algo
• 在线阅读 > https://www.hello-algo.com/
• 下载 PDF > https://github.com/krahets/hello-algo/releases

本项目旨在创建一本开源、免费、对新手友好的数据结构与算法入门教程。

• 全书采用动画图解，内容清晰易懂、学习曲线平滑，引导初学者探索数据结构与算法的知识地图。
• 源代码可一键运行，帮助读者在练习中提升编程技能，了解算法工作原理和数据结构底层实现。
• 提倡读者互助学习，欢迎大家在评论区提出问题与分享见解，在交流讨论中共同进步。
• 算法源代码皆可一键运行，支持 Python、C++、Java、C#、Go、Swift、JavaScript、TypeScript、Dart、Rust、C 和 Zig 等语言。

内容结构

本书的主要内容如图所示。

• 复杂度分析：数据结构和算法的评价维度与方法。时间复杂度和空间复杂度的推算方法、常见类型、示例等。
• 数据结构：基本数据类型和数据结构的分类方法。数组、链表、栈、队列、哈希表、树、堆、图等数据结构的定义、优缺点、常用操作、常见类型、典型应用、实现方法等。
• 算法：搜索、排序、分治、回溯、动态规划、贪心等算法的定义、优缺点、效率、应用场景、解题步骤和示例问题等。

注意：这本书不是我写的哦！作者是@krahets。

本人觉得这本书写的是很不错的，欢迎去学习。

在嵌入式系统开发中，控制LED的亮度或电机的速度等模拟控制任务常常需要使用PWM（脉冲宽度调制）技术。STM32微控制器提供了强大的定时器功能，可以方便地生成PWM信号。本文将详细介绍如何在STM32上配置定时器的PWM输出。

定时器与引脚映射

STM32的定时器具有多个通道，每个通道都可以输出PWM信号。但是，并非所有的GPIO引脚都可以用于所有定时器的通道。每个定时器通道通常只能映射到一组特定的引脚上，这些引脚被称为复用功能（Alternate Function，AF）引脚。

如何确定引脚与定时器通道的映射关系？

1. 查看数据手册：STM32的数据手册会详细列出每个定时器通道可以映射到哪些引脚。通常，这些信息会在引脚定义和复用功能章节中给出。

2. 使用STM32CubeMX工具：STM32CubeMX是一个图形化配置工具，可以用来配置STM32的外设。通过这个工具，你可以直观地选择定时器和对应的通道，

配置TIM通道的PWM输出

假设我们使用STM32F103RCT6微控制器，并希望配置TIM3的通道2输出PWM信号，因为我的LED是这个TIM通道，按自己的来更改。以下是配置过程的详细步骤：

1. 使能时钟

首先，需要使能定时器和GPIO端口的时钟。

1
2

RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); // 使能TIM3时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); // 使能GPIOB时钟

2. GPIO配置

接下来，配置GPIO端口的引脚为复用推挽输出模式。在这个例子中，我们使用TIM3的通道2，对应的GPIO引脚是PB5。

1
2
3
4
5

GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5; // PB5
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; // 复用推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; // IO口速度为50MHz
GPIO_Init(GPIOB, &GPIO_InitStructure); // 初始化GPIOB.5

3. 定时器基本配置

在配置PWM之前，需要对定时器进行基本的配置，包括预分频器、计数模式、自动重装载值等。

1
2
3
4
5
6
7

TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_TimeBaseStructure.TIM_Prescaler = 71; // 预分频器值
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // 向上计数模式
TIM_TimeBaseStructure.TIM_Period = 499; // 自动重装载值
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; // 时钟分频
TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);

4. PWM模式配置

现在，我们可以配置定时器的PWM模式。这包括设置PWM模式、输出状态、占空比、输出极性等。

1
2
3
4
5
6
7
8
9

TIM_OCInitTypeDef TIM_OCInitStructure;
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; // PWM模式1
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; // 使能输出
TIM_OCInitStructure.TIM_Pulse = 0; // 初始占空比
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; // 输出极性高
TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset; // 空闲状态
TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCIdleState_Reset; // 互补空闲状态
TIM_OC2Init(TIM3, &TIM_OCInitStructure); // 配置TIM3通道2为PWM模式
TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable); // 使能TIM3通道2的预装载寄存器

5. 启动PWM

最后，启动定时器，PWM信号就会出现在配置好的引脚上。

1

TIM_Cmd(TIM3, ENABLE); // 使能TIM3

注意：需要写对对应的TIM和对应的通道，不然可能无效，如果不行，可以使用STM32CubeMX工具来找。

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include "stm32f10x.h"
#include "stm32f10x_tim.h"
#include "delay.h"

void PWM_Init(void)
{
    /*开启时钟*/
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);          //开启TIM3的时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);         //开启GPIOB的时钟
    
    /*GPIO初始化*/
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;                      // PB5对应TIM3的通道2
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);                         //将PB5引脚初始化为复用推挽输出

    // 定时器初始化
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    TIM_TimeBaseStructure.TIM_Prescaler = 71; // 预分频器
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // 向上计数模式
    TIM_TimeBaseStructure.TIM_Period = 499; // 自动重装载值
    TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; // 时钟分频
    TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);

    // 使能定时器3
    TIM_Cmd(TIM3, ENABLE);

    // PWM模式配置
    TIM_OCInitTypeDef TIM_OCInitStructure;
    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; // PWM模式1
    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; // 使能输出
    TIM_OCInitStructure.TIM_Pulse = 0; // 初始占空比
    TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; // 输出极性高
    TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High; // 互补输出极性高
    TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset; // 空闲状态
    TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCIdleState_Reset; // 互补空闲状态

    // 配置TIM3通道2
    TIM_OC2Init(TIM3, &TIM_OCInitStructure);

    // 使能TIM3通道2的预装载寄存器
    TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable);
}



void PWM_SetCompare(uint16_t Compare)
{
    TIM_SetCompare2(TIM3, Compare); //设置CCR3的值
}

int main(void) {
    PWM_Init();
uint16_t value = 0;
while(1) {
while(value < 500) {
value++;
 PWM_SetCompare(value);
 delay_ms(2);
 }
 
 while(value) {
value--;
 PWM_SetCompare(value);
 delay_ms(2);
 }
 delay_ms(200);
}
}