likes
comments
collection
share

CI 持续集成与构建高质量 Go 应用

作者站长头像
站长
· 阅读数 53

CI 持续集成与构建高质量 Go 应用

❝

可以遗憾，但不要后悔。 

我们留在这里，从来不是身不由己。 

——— 而是选择在这里经历生活

❞

目录

当开发者在 Go 项目中工作时，通过使用有效的工具和技术可以大大提高代码质量和开发速度。本文中将详细探讨如何使用 golangci-lint 工具进行代码风格检查和自动修复、如何集成 Git 和 Goland IDE，并介绍一些有用的 Git 前端 JS 工具库。

首先，我们简要介绍了 golangci-lint 工具的使用方法，该工具可以帮助检查错误、提高代码质量和性能，同时可以与 Goland 集成以增强开发效率和质量。此外，本文还介绍了如何根据特定项目需求来配置 linter，以及使用 golangci-lint 自动修复常见问题来减少手动修复代码的时间和工作量。

接下来，我们强调了版本控制工具 Git 和使用 commitizen 库管理 Git 提交消息的重要性。我们简要介绍了 Git Commit 的最佳实践和常见问题，并详细说明了如何使用 commitizen 库规范化提交消息格式。同时，我们还介绍了如何使用 git hooks 和 husky 等 Git 工具库来在提交代码之前进行代码质量检查和测试，从而保证代码库的质量和稳定性。

本文旨在帮助读者了解如何使用这些工具和技术来提高 Go 项目的开发效率和质量，并掌握一些有用的 Git 工具库，帮助管理代码库并保证代码质量。

  1. CI/CD 理念与实践
  2. Go 编程格式规范（一）
  3. Go 代码检测工具
  4. Go 编程格式规范（二）
  5. 如何配置 Goland IDE

CI/CD 理念与实践

CI/CD 是一种软件开发理念和实践，旨在通过自动化流程和工具实现代码质量改进、开发效率提升和产品交付加速的目标。其中包括持续集成（Continuous Integration, CI）、持续交付（Continuous Delivery, CD）、持续部署（Continuous Deployment, CD）、自动化测试和构建、协作和反馈等关键要素。CI/CD 可以帮助团队快速交付高质量的产品，并不断改进和优化产品和流程。

以下是红帽对 CI/CD 的解释和应用案例：www.redhat.com/en/topics/d…

流程图

以下是一个简单的 CI/CD 流程图，仅供参考：

        ┌────────────┐         ┌──────────────┐         ┌───────────────┐
        │    代码库   │────────▶│   构建服务器   │────────▶│    测试环境    │
        └────────────┘         └──────────────┘         └───────────────┘
               ▲                      ▲                         ▲
               │                      │                         │
               │                自动化构建、测试               自动化部署
               │                      │                         │
               │                      │                         │
        ┌────────────┐         ┌──────────────┐         ┌───────────────┐
        │ 版本控制工具 │◀────────│  持续集成工具  │◀────────│   持续交付工具  │
        └────────────┘         └──────────────┘         └───────────────┘

在这个流程图中，团队成员将代码提交到版本控制工具中。持续集成工具在检测到新的代码提交后，会自动触发自动化构建和测试过程，并生成构建报告和测试报告。如果构建和测试都成功通过，则持续交付工具会将应用程序自动部署到测试环境中进行进一步的测试和验证。如果测试通过，则持续交付工具会自动将应用程序交付到生产环境中。

需要注意的是，这只是一个简单的示意图，实际的 CI/CD 流程可能更加复杂和多样化。例如，在持续集成（CI）阶段，可能涉及到静态代码分析、代码覆盖率、代码质量评估等多个环节；在持续交付阶段，可能涉及到容器化技术、自动化审批、绿蓝部署等多个技术和方法。因此，在设计和实践 CI/CD 流程时，需要根据具体情况进行灵活的调整和优化。

应用组件

  1. 代码托管：将代码存放在版本控制系统（如 GitHub、GitLab 等）中，实现代码共享和版本管理；
  2. 自动化构建：使用持续集成工具（如 Jenkins、Travis CI 等）对代码进行自动化构建，并生成可执行文件、库文件等；
  3. 自动化测试：使用自动化测试工具（如 JUnit、Selenium、Appium 等）对构建后的代码进行自动化测试，并生成测试报告；
  4. 静态代码分析：使用静态代码分析工具（如 golangci-lint、PMD、Pylint 等）对代码进行检查，以检测潜在的错误和代码质量问题；
  5. 自动化部署：使用持续交付工具（如 Spinnaker、AWS CodePipeline 等）将构建好的应用程序自动部署到测试环境或预生产环境中；
  6. 持续交付：使用自动化审批工具（如 SonarQube、Checkmarx 等）对部署结果进行审批，以确保交付的代码符合要求；
  7. 持续部署：使用持续部署工具（如 Kubernetes、Docker Swarm 等）将通过了所有测试和审批的应用程序自动部署到生产环境中。

需要注意的是，在实践过程中，团队可能会选择其他容器编排技术（如 Docker Swarm、Nomad 等）替代 Kubernetes，或者使用传统的虚拟机来进行部署。同时，Ansible 也可以与 Kubernetes 或 Docker 搭配使用，用于自动化部署和配置管理。

综上所述，具体的 CI/CD 流程可能因团队规模、项目特点、技术选型等原因而有所差异。在设计和实践 CI/CD 流程时，需要根据具体情况进行灵活的调整和优化，并在实践过程中保持持续学习和改进的精神。

Go 编程格式规范（一）

编程格式规范主要包括两部分，其中第一部分也是最为重要的，即代码格式与规范。在这一部分中，我们着重强调编写代码时遵循一定的格式标准和规范，以提高代码可读性、可维护性和可扩展性。当然它并不与代码质量、性能和正确性强相关。在实践中，遵循规范可以使代码更加易于理解和修改，并有助于减少潜在的错误和安全问题。同时，不遵循规范可能会导致代码难以维护、扩展和重构，最终影响代码的质量和性能。

Go 代码规范

代码示例对比

俗话说，没有规矩不成方圆，同样适用于代码，甚至可以写成下面这样（用 JS 举个例子）：

Bad

不及格，不可维护、不可扩展的代码！虽然可以运行，但整体代码结构非常难看！

  const product={
    name: '商品',
    price:10,
    num : 5
  };
  
  var total =0;
function calculate(){
  total=product.price*product.num
  console.log(product.name+"总价为："+total);
}
calculate()

Good

修正后，统一规范的代码应该是这个样子。

const product = {
  name: '商品',
  price: 10,
  num : 5
}

let total = 0

const calculate = () => {
  total = product.price * product.num
  console.log(`${product.name}总价为：${total}`)
}

calculate()

整活艺术大赏

C 语言混乱代码大赛（International Obfuscated C Code Contest，简称 IOCCC）是一个历史悠久的比赛，每年都会举办一次。自 1984 年以来，这个比赛已经成功地举办了多届，吸引了全球各地的程序员和编码爱好者参与。

比赛的目的是编写最难以阅读、理解和维护的 C 语言代码。虽然这些代码可能难以理解，但它们通常也具有独特的创意和艺术价值，因为它们需要使用各种技巧和技术，将程序逻辑压缩到尽可能少的字符中。

虽然该比赛不是国际标准的竞赛活动，但仍然广受欢迎。如果您对 C 语言开发感兴趣，建议关注该比赛，并尝试提交一些有趣或有创意的混乱代码，以挑战自己的技能和想象力。

www.techug.com/post/code-m…

一道开胃菜

来优化下代码吧：来测试下你的代码习惯还 OK 吗

Go 代码检测工具

在开发过程中，我们不能仅依赖 CI 流程来进行代码检查。相反，我们应该在平时开发中就边开发边检查代码，及时发现和解决问题，而不是等到上线之前才一股脑地修复。

此外，在面对质量安全团队的反馈时，我们不能简单地抱怨他们的挑剔或无关紧要。如果我们经常需要与 QA 团队接触，则说明我们的代码质量可能存在问题。因此，我们应注重代码质量和可维护性，采用最佳实践和工具提高开发效率和团队协作能力，以确保代码满足产品需求和用户期望。

当然，在 CI 流程中进行代码检查也是必要的，作为代码质量保障的最后一道防线。我们需要使用类似 GolangCI-Lint 这样的检查工具和自动化流程来检测我们的代码，以确保代码符合最佳实践和标准，并且不会引入潜在的漏洞和安全问题。

总之，我们需要在整个开发生命周期中注重代码质量和可维护性，不断改进和加强我们的开发工具和流程，以提高代码质量和团队协作效率。

常用工具

Go 代码的检测工具有很多，以下是一些常用的 Go 代码检查工具：

工具说明
gofmtGo 标准库自带的格式化工具，用于规范化 Go 代码的格式和布局。
golint由 Go 的创造者之一发布的 Linter 工具，可用于检查和修复 Go 代码中的语法错误和不规范的用法。
go vet类似于编译器的静态分析工具，可检查 Go 代码中的常见错误和潜在问题。
goimportsGo 语言开发中一个非常实用的工具，其主要功能是帮助自动管理 Go 代码中的导入声明。具体来说，它可以根据一定的规则自动添加、删除或调整导入声明。
golangci-lintGolang 社区开发的综合性 Linter 集成工具，它继承了很多静态代码分析工具，可以检查代码中的各种问题，包括语法错误、代码风格、性能问题等。

goimports

安装

➜  ~ go install golang.org/x/tools/cmd/goimports@latest

运行

对 XXX 路径下所有 .go 文件自动 format 导入相关代码

# 选项说明：
# -w 表示要将修改后的代码写回到文件中，即覆盖原文件；
#
# -local code.company.org,your-repo：表示指定本地导入路径前缀，以便 goimports 识别和处理相应的导入声明。
# 其中 code.company.org 和 your-repo 分别代表你所在公司或组织的域名和代码仓库名称。这个参数是可选的，根据实际情况而定；
#
# ./XXX：表示要处理的 Go 代码文件或目录，其中 XXX 可以是具体的文件或目录名，也可以是通配符等形式。
#
# 综上所述，这条命令的作用是在当前目录下递归处理所有 Go 代码文件，使用 goimports 工具自动调整其导入
# 声明，并将修改后的结果直接写回到每个文件中。同时，根据需要可以通过 -local 参数指定本地导入路径前缀，
# 以更好地适应项目的特定需求。
➜  ~ goimports -w -local code.company.org,your-repo ./XXX

效果

优化前

CI 持续集成与构建高质量 Go 应用

优化后

CI 持续集成与构建高质量 Go 应用

golangci-lint

通过使用 golangci-lint，可以有效地提高 Go 代码的质量和可维护性，并确保代码在生产环境中的稳定性和可靠性。

说明

由于配置项繁多，无需全都开启。根据各自组内项目规范，我们只需要集成一些必须遵守的 Linter 工具。如果所有规范都被遵循，将会显著降低编写代码的效率，因此我们需要权衡取舍。

官网

golangci-lint.run/

安装

Golangci-lint 是 GO 语言编写的，可以从源代码安装它，在终端输入命令：

➜  ~ go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

环境

在 Mac 下配置环境变量：

SDK 版本包管理方式配置说明
Go 1.14 或更高版本默认我们使用 go mod 方式，不再需要设置 $GOPATH 环境变量在这种情况下，Go 会自动将依赖项下载到您的项目目录中，并缓存它们以供下次使用。默认情况下，可执行文件会被安装到 $HOME/go/bin 目录中。我们可将其添加到 ~/.zshrc 文件中，以便每次打开终端时自动加载：echo 'export PATH="$PATH:$HOME/go/bin"' >> ~/.zshrc && source ~/.zshrc

经过上述配置后，即可在终端中直接运行 golangci-lint 命令了。

命令

  • 查看版本
➜  ~ golangci-lint --version
golangci-lint has version v1.52.2 built with go1.20.4 from (unknown, mod sum: "h1:FrPElUUI5rrHXg1mQ7KxI1MXPAw5lBVskiz7U7a8a1A=") on (unknown)
  • 查看语法
➜  ~ golangci-lint -h
Smart, fast linters runner.

Usage:
  golangci-lint [flags]
  golangci-lint [command]

Available Commands:
  cache       Cache control and information
  completion  Generate the autocompletion script for the specified shell
  config      Config
  help        Help
  linters     List current linters configuration
  run         Run the linters
  version     Version

Flags:
      --color string              Use color when printing; can be 'always', 'auto', or 'never' (default "auto")
  -j, --concurrency int           Concurrency (default NumCPU) (default 10)
      --cpu-profile-path string   Path to CPU profile output file
  -h, --help                      help for golangci-lint
      --mem-profile-path string   Path to memory profile output file
      --trace-path string         Path to trace output file
  -v, --verbose                   verbose output
      --version                   Print version

Use "golangci-lint [command] --help" for more information about a command.
  • 查看支持的 Linter
➜  ~ golangci-lint help linters
Enabled by default linters:
errcheck: errcheck is a program for checking for unchecked errors in Go code. These unchecked errors can be critical bugs in some cases [fast: false, auto-fix: false]
gosimple (megacheck): Linter for Go source code that specializes in simplifying code [fast: false, auto-fix: false]
govet (vet, vetshadow): Vet examines Go source code and reports suspicious constructs, such as Printf calls whose arguments do not align with the format string [fast: false, auto-fix: false]
ineffassign: Detects when assignments to existing variables are not used [fast: true, auto-fix: false]
staticcheck (megacheck): It's a set of rules from staticcheck. It's not the same thing as the staticcheck binary. The author of staticcheck doesn't support or approve the use of staticcheck as a library inside golangci-lint. [fast: false, auto-fix: false]
typecheck: Like the front-end of a Go compiler, parses and type-checks Go code [fast: false, auto-fix: false]
unused (megacheck): Checks Go code for unused constants, variables, functions and types [fast: false, auto-fix: false]

Disabled by default linters:
asasalint: check for pass []any as any in variadic func(...any) [fast: false, auto-fix: false]
asciicheck: Simple linter to check that your code does not contain non-ASCII identifiers [fast: true, auto-fix: false]
bidichk: Checks for dangerous unicode character sequences [fast: true, auto-fix: false]
bodyclose: checks whether HTTP response body is closed successfully [fast: false, auto-fix: false]

// omit...

运行

  • 手动运行 golangci-lint run ，检测选择要分析的目录和文件：
➜  ~ golangci-lint run examples/... 
examples/demo_test.go:9:1: tests: ExampleGin refers to unknown identifier: Gin (govet)
func ExampleGin() {
^

配置

  • 完整的 golangci.yml 配置参考：

golangci-lint.run/usage/linte…

  • GolangCI-Lint 在当前工作目录的以下路径中查找配置文件：
.golangci.yml
.golangci.yaml
.golangci.toml
.golangci.json

Go 编程格式规范（二）

编程格式规范主要包括两部分，其中第二部分同样至关重要，即 Git 提交规范与 Git Hooks，特别是在大型合作的后端项目中。在这一部分中，我们强调通过定义良好的提交信息格式、使用 Git 钩子脚本等方式来规范团队成员之间的代码贡献和版本控制操作，并借此提高代码质量和协作效率。

Git 提交规范

约定式提交规范

AngularJS 社区提出了一套基于 Git 的提交信息规范，也称为 Angular 提交规范。这个规范在软件开发社区中得到了广泛的应用和推广，成为了一种通用的提交信息规范，被许多开源项目所采纳和使用。

Angular 提交规范包括两部分：提交类型和提交主题。提交类型用于描述提交的目的或行为，例如修复错误、添加功能或重构代码等。提交主题则是对提交目的的更详细的描述，可以简要说明具体修改的内容、原因等。

部分描述
类型（type）指的是本次提交的类型，可以是新功能、修复 Bug、文档修改、重构代码等；
范围（scope）指的是本次提交涉及到的模块或组件，可以是项目名称、文件名、函数名等；
主题（subject）指的是本次提交的主题或概要，应该尽量简洁明了，不超过 50 个字符；
正文（body）是本次提交的详细说明，应该包含本次提交的详细信息和原因，并为其他开发者提供足够的上下文和背景；
脚注（footer）可以包含一些额外的信息，如解决的问题、引用的文献、关联的 Issue 等。

下面是 Angular 提交规范中定义的一些常见提交类型：

  • feat：新功能
  • fix：修复问题/错误
  • refactor：代码重构
  • style：样式调整（不影响代码含义的改动）
  • docs：文档更新
  • chore：构建或辅助工具的变动
  • test：测试用例的变动
  • perf：性能优化
  • ci：CI 配置文件或脚本的变动

通过遵循 Angular 提交规范，我们可以编写清晰、易于理解和组织的提交信息，并且使得团队成员更容易理解和评估代码变更的目的和影响。

Git 命令手动提交

# 将当前目录下的所有文件或修改过的文件添加到暂存区（也称为索引或缓存）中，以便后续提交。
➜  ~ git add .

# 将暂存区中的文件提交到本地 Git 仓库中，并添加一条注释信息（-m参数）作为本次提交的说明。
➜  ~ git commit -m "Initial commit"

# 将本地 Git 仓库中的代码推送到远程 Git 仓库（origin）的 master 分支上。
➜  ~ git push origin master

Goland IDE 提交

Bad 提交样例

CI 持续集成与构建高质量 Go 应用

Good 提交样例

CI 持续集成与构建高质量 Go 应用

当然，标准化的提交代码有助于提高团队协作效率和代码质量，但对于一些开发者来说，这样写提交信息可能会感到繁琐和麻烦。不过幸好，我们可以借助一些工具和插件来简化提交流程，甚至监督和自动化提交规范。

例如，许多编辑器或 IDE 都提供了 Git 插件，可以帮助开发者快速完成代码提交、合并分支等操作，并支持自定义提交信息模板和校验规则。另外，还可以使用一些第三方的提交规范检查工具，如 commitlint、Husky 等，通过预设的规则和脚本进行提交信息校验和修正，确保提交信息符合标准化要求。

Git Hooks 介绍

详细的 Hooks 介绍：git-scm.com/docs/githoo…

Git Hooks 是 Git 仓库中内置的脚本程序，由 Git 提供，可以在特定的 Git 操作（如 commit、push 等）之前或之后运行自定义的脚本程序。

通过创建 Git Hooks 脚本，开发人员可以为 Git 操作添加自定义逻辑，如在每次提交之前运行代码检查工具、运行测试或构建应用程序等操作，从而提高代码质量和可维护性。

常见的 Git Hooks 包括：pre-commit、post-commit、pre-push、post-merge 等。

NPM 工具介绍

工欲善其事，必先利其器，介绍几款不错的前端库：

工具包描述说明
Commitizen用于规范化 Git 提交信息的工具。它可以强制要求开发人员按照一定的格式书写提交信息，以便更好地管理和跟踪代码变更历史，并促进团队协作和代码审查。Commitizen 可以与 Git 仓库集成，也可以通过一些文本编辑器（如 VSCode）的插件来使用。
Husky基于 Node.js 的 Git Hook 工具，可以在 Git 操作前或后自动执行用户定义的脚本。Husky 可以帮助开发人员在版本控制过程中添加各种钩子（如 pre-commit、post-commit 等），以确保代码符合预期并进行代码检查等操作。
cz-conventional-changelog该库提供了一组默认的提交类型、范围和描述，以及相应的格式化模板。使用时，用户可以根据自己的需求在这些选项中进行选择和填写，或者使用默认值进行快速提交。cz-conventional-changelog 适合需要快速上手并且不需要过多定制的项目。
cz-customizable该库允许用户自定义提交类型、范围和描述等内容，并提供了灵活的配置方式。用户可以通过简单地修改配置文件，来添加、删除或者修改提交选项，从而满足个性化和特殊需求。cz-customizable 更加灵活和可定制化，适合需要定制化提交信息风格的项目。
standard-version一款遵循语义化版本（semver）和 commit message 标准规范的版本自动化工具，它还可以使生成 changelog 自动化。

如何配置 Goland IDE

众所周知，工欲善其事必先利其器。在 Go 语言开发过程中，JetBrains Goland 是一款非常优秀的集成开发环境，结合其它一系列工具，可以让我们的开发效率得到极大的提升。因此，在本文中，我们以 JetBrains Goland 为例，向大家介绍如何使用一些实用的辅助工具来优化开发体验，从而让 Goland 变得异常好用！

集成 golangci-lint 工具

推荐指数：🌟🌟🌟🌟🌟

  1. 打开设置

CI 持续集成与构建高质量 Go 应用

  1. Goland -> Settings -> Tools -> File Watchers

CI 持续集成与构建高质量 Go 应用

  1. 注意将 Arguments 中 --disable=typecheck 删掉

CI 持续集成与构建高质量 Go 应用

  1. Goland -> Settings -> Tools -> Actions on Save

CI 持续集成与构建高质量 Go 应用

  1. 不规范的代码将被检测并提示出来

CI 持续集成与构建高质量 Go 应用

  1. 一个.golangci.yml 演示文件（并非最佳实践配置😯）：
# 使用 golangci-lint 的版本
linters-settings:
  golangci-lint:
    version: "1.42.0"

# 检查哪些 linter 
linters:
  # golint 可以检查 Go 代码是否符合 Go 官方编码规范，但有时候可能会产生误报。
  golint:
    enabled: true   # 是否启用
    min-confidence: 0.8   # 最小的置信度 (0~1)，即只在高于此阈值的问题上发出警告
    exclude-rules:   # 排除一些规则
      - exported
      - stutters
  # govet 可以检查 Go 代码中的潜在错误和代码不规范的地方。
  govet:
    enabled: true
    vettool: ""
  # staticcheck 可以检查 Go 代码中的许多常见错误、代码不规范的地方等。
  staticcheck:
    enabled: true
  # nestif 可以帮助你减少嵌套代码块，并且提高代码可读性和可维护性。
  nestif:
    enabled: true
  # gocritic 是一个高效的代码审查工具，可以检查大量常见的 Go 编程错误。
  gocritic:
    enabled: true
  # goimports 可以自动格式化 Go 代码并管理导入语句（包括添加和删除）。
  goimports:
    enabled: true
  # stylecheck 可以帮助你检查缺少注释、命名不规范等代码风格问题。
  stylecheck:
    enabled: true

# 指定哪些目录下的代码需要被检查
run:
  paths:
    - ./...

# 单独指定某些文件或目录的检查配置
linters-override:
  testdata:
    # 关闭所有 linters 在 testdata 目录下的检查
    enabled: false
  cmd/:
    # 针对 cmd 目录下的文件使用特定的 linters 配置
    golint:
      min-confidence: 0
    govet:
      check-shadowing: false

# 是否在 CI 环境下检查代码
ci:
  # 执行所有 lint 操作
  run:
    hooks:
      - command: "make lint"
  # 只执行指定的 linter
  skip-install: true

集成 goimports 工具

推荐指数：🌟🌟🌟🌟🌟

  1. Goland -> Settings -> Editor -> Code Style -> Go

CI 持续集成与构建高质量 Go 应用

使用 Conventional Commit 插件

推荐指数：🌟🌟🌟

点评：对于频繁提交代码的人来说，虽然 Conventional Commit 插件在一定程度上能够规范和便捷提交流程，但实际使用起来仍不是很方便。

  1. Goland -> Settings -> Plugins -> Marketplace

CI 持续集成与构建高质量 Go 应用

  1. Goland -> Settings -> Version Control -> Commit

CI 持续集成与构建高质量 Go 应用

  1. Build Commit Message

CI 持续集成与构建高质量 Go 应用

  1. Commit and Push

CI 持续集成与构建高质量 Go 应用

集成 commitizen 系列工具

推荐指数：🌟🌟🌟🌟

点评：想要规范化提交，确实需要借助各种炫酷的前端 JS 库。毕竟 Angular 规范已经在前端和后端开发中广泛使用，也证明了其实用性。

当然，在 Go 官方的 Contribution Guide 中，也提到了 "Good commit messages" ，我们应该尽量遵循 Go 官方的实践。此外，还有一些质量不错的博客，如 zchee.github.io/golang-wiki… 等，可以帮助我们更好地理解和应用 Git 提交信息的规范和最佳实践。

  1. 快速安装 Node.js / NPM 环境及相关工具库
# 系统实验环境 Debian 12

root@localhost:~# apt-get install -y nodejs npm

root@localhost:~# node -v
v18.13.0

root@localhost:~# npm -v
9.2.0

root@localhost:~# npm install -g yarn

root@localhost:~# yarn -v
1.22.19

root@localhost:~# yarn global add commitizen

root@localhost:~# yarn global add cz-customizable

root@localhost:~# yarn global add cz-conventional-changelog

root@localhost:~# ll /usr/local/bin
total 4
lrwxrwxrwx 1 root root 57 May 31 13:35 commitizen -> ../share/.config/yarn/global/node_modules/.bin/commitizen
lrwxrwxrwx 1 root root 49 May 31 13:35 cz -> ../share/.config/yarn/global/node_modules/.bin/cz
lrwxrwxrwx 1 root root 54 May 31 13:35 cz-cust -> ../share/.config/yarn/global/node_modules/.bin/cz-cust
lrwxrwxrwx 1 root root 62 May 31 13:35 cz-customizable -> ../share/.config/yarn/global/node_modules/.bin/cz-customizable
lrwxrwxrwx 1 root root 53 May 31 13:35 git-cz -> ../share/.config/yarn/global/node_modules/.bin/git-cz
lrwxrwxrwx 1 root root 36 May 31 02:33 yarn -> ../lib/node_modules/yarn/bin/yarn.js
lrwxrwxrwx 1 root root 36 May 31 02:33 yarnpkg -> ../lib/node_modules/yarn/bin/yarn.js
  1. 在项目根路径下执行，会生成 node_modules 依赖包目录
# 初始化JS项目
root@localhost:~# yarn

# 若全局安装，则无须再安装
root@localhost:~# yarn add -D cz-customizable cz-conventional-changelog
  1. 新建 package.json 文件
{
  "scripts": {
    "commit": "git add . && git cz"
  },
  "config": {
    "commitizen": {
      // "path": "node_modules/cz-conventional-changelog"
      "path": "node_modules/cz-customizable"
    }
  },
  "devDependencies": {
    "cz-conventional-changelog": "^3.3.0",
    "cz-customizable": "^7.0.0"
  }
}
  1. 修改 .gitignore 文件。因为这是一个 Go 项目，所以我们可以选择屏蔽一些 JS 工具的配置文件和依赖项。
# shield
node_modules/
.czrc
.cz-config.js
package.json
yarn.lock
  1. 如果只是想快速上手并且不需要过多定制，推荐使用 cz-conventional-changelog 库，该库可以开箱即用。

CI 持续集成与构建高质量 Go 应用

  1. 如果需要自定义提交信息格式，更推荐使用 cz-customizable 库，并定义 .cz-config.js 文件。
module.exports = {
    // 可选类型
    types: [
        { value: 'feat', name: 'feat 🍄:    新增新的特性' },
        { value: 'fix', name: 'fix 🐛:    修复 BUG' },
        { value: 'docs', name: 'docs 📄:    修改文档、注释' },
        { value: 'style', name: 'style 🌈:    对代码格式的修改不影响逻辑' },
        { value: 'refactor', name: 'refactor 🧩:    代码重构(注意和 feat/bug 区分开)' },
        { value: 'perf', name: 'perf ✨:    提升性能优化' },
        { value: 'test', name: 'test 👀:    添加一个测试' },
        { value: 'chore', name: 'chore 🪐:    构建过程或辅助工具的变动' },
        { value: 'revert', name: 'revert ⏪:     版本回滚' },
        { value: 'tool', name: 'tool 🛠:    开发工具变动(构建、脚手架工具等)' },
        { value: 'build', name: 'build 📦:    编译打包' },
        { value: 'update', name: 'update 🚀:    第三方库升级 ' }
    ],
    // 范围
    scopes: [
        { name: '组件' },
        { name: '样式' },
        { name: '文档' },
        { name: '其它' }
    ],
    allowTicketNumber: false,
    isTicketNumberRequired: false,
    ticketNumberPrefix: 'TICKET-',
    ticketNumberRegExp: 'd{1,5}',
    // 消息步骤
    messages: {
        type: '选择一种你的提交类型:',
        scope: '选择一个scope (可选):',
        customScope: 'Denote the SCOPE of this change:',
        subject: '简要说明:\n',
        body: '详细说明，使用"|"换行(可选)：\n',
        breaking: '非兼容性说明 (可选):\n',
        footer: '关联关闭的issue，例如：#29, #47(可选):\n',
        confirmCommit: '确定要提交以上信息吗?'
    },
    allowCustomScopes: true,
    allowBreakingChanges: ['新增', '修复'],
    // 跳过
    skipQuestions: ['body', 'footer'],
    breaklineChar: '|',
    footerPrefix: 'ISSUES CLOSED:',
    // 文字长度默认是72
    subjectLimit: 72
}

CI 持续集成与构建高质量 Go 应用

  1. 可以创建一个 Goland 的外部工具，来方便地使用 git cz 命令。

CI 持续集成与构建高质量 Go 应用

  1. 为了更加方便地调用，可以设置一个快捷键来执行相关操作。如：control + option + command + M

CI 持续集成与构建高质量 Go 应用

  1. 来总结下我们的 git cz 调用方式，可以使用终端命令行、右键菜单、菜单栏等，最推荐的是使用快捷键方式（注意指令冲突）

CI 持续集成与构建高质量 Go 应用

  1. 确定没任何问题，就可以放心的提交代码了

CI 持续集成与构建高质量 Go 应用

尽管提交代码确实是一项繁琐的任务，但我们仍然建议将 “单一职责原则” 应用于提交规范中，并将其拆分为更小、逻辑上更独立的提交。此外，我们鼓励使用简洁明了、50 个字符以内的描述，以更好地解释提交内容。请尽可能坚持这种模式！

配置 husky 工具

推荐指数：🌟🌟🌟🌟

点评：Husky 是构建自动化 git 提交流程中非常重要的一环！最终我们希望实现的效果是：在使用 git 提交版本时，如果校验发现“提交描述信息”或“更新代码文件”的内容不符合预期，就阻止当前提交，并抛出对应的错误提示。

需要注意的是，这个和 Goland 的配置没有太大关系。在本节中，我们只会简要介绍实现方法，并不作为重点。如果需要更详细的信息，请自行参考官方文档。

在项目的 .git/hooks 目录下有很多钩子，可以根据需要自定义不同的功能。其中常用的 Hooks 包括：

Git 钩子方法调用时机说明
pre-commitgit commit 执行前它不接受任何参数，并且在获取提交日志消息并进行提交之前被调用。脚本 git commit 以非零状态退出会导致命令在创建提交之前中止。会在提交前被调用，并且可以按需指定是否要拒绝本次提交。
commit-msggit commit 执行前可用于将消息规范化为某种项目标准格式。还可用于在检查消息文件后拒绝提交。可以用来规范化标准格式，并且可以按需指定是否要拒绝本次提交。

按照以下方式进行配置，完成后可以进行提交测试。如果为不符合预期的代码格式将会被自动阻拦！

# 1. 安装 husky
root@localhost:~# yarn add -D husky

# 2. 启动 hooks，生成 .husky 目录
root@localhost:~# npx husky install
husky - Git hooks installed

# 3. 在 package.json 中生成 prepare 指令
root@localhost:~# npm pkg set scripts.prepare="husky install"

# 4. 测试指令执行成功
root@localhost:~# yarn prepare
yarn run v1.22.19
$ husky install
husky - Git hooks installed
✨  Done in 0.54s.

# 5. 初始的 .husky 目录结构
root@localhost:~# tree -a .husky --noreport
.husky
└── _
    ├── .gitignore
    └── husky.sh

# 6. 添加 lint 规则到 pre-commit 文件中
root@localhost:~# npx husky add .husky/pre-commit "golangci-lint run ./... && go test ./..."       
husky - created .husky/pre-commit

# 7. 查看 pre-commit 文件内容
root@localhost:~# cat .husky/pre-commit
#!/usr/bin/env sh
. "$(dirname -- "$0")/_/husky.sh"

golangci-lint run ./... && go test ./...

# 在提交代码时，该钩子会首先运行 golangci-lint 命令来检查 Go 代码格式是否符合规范，
# 如果格式不符合，则阻止提交，并抛出对应的错误提示；如果格式符合规范，则运行 go test 
# 命令来检查代码是否能够通过测试，如果通过了测试，则允许代码提交。

Plugins 代码搭档

推荐工具是否收费作用
Github Copilot收费，试用 30 天可以根据自然语言描述编写完整的函数，整段代码的生成
Tabnine免费（短代码补全）免费的行级代码补全工具，收费就是另一种待遇了
ChatGPTChatGPT Plus 会员订阅它允许用户以对话方式与模型交互，向它提问或提示它生成响应。这些模型可以处理更复杂的任务。

额外补充的话题

Goland 还有哪些使用技巧？

blog.jetbrains.com/zh-hans/201…

blog.jetbrains.com/zh-hans/201…

blog.jetbrains.com/zh-hans/202…

理论 or 实践？

本期主题是关于代码开发和维护实战技能的讨论，这些技能对编写高质量、易于维护的代码非常重要。如果您希望立即了解实际代码开发的技巧和最佳实践，我们推荐您学习本期涉及的主题。

同时，如果您想系统地学习软件工程的理论和实践方法，我们也强烈推荐阅读《代码大全》这本经典书籍。该书涵盖了众多与代码开发无关的主题，如文档编写、项目管理、团队沟通等，可以为您提供更广泛、更系统的视野和知识，并深入介绍软件开发和设计的基本原则。

在实际工作中，理论和实践同样重要，因此我们应该注重平衡并掌握两者。

为什么前端领域有这么多 Git 提交规范和开源工具，而后端却似乎缺少相应的统一工具呢？

前端开发通常使用 JavaScript 语言。在这个领域中，采用 Git 提交规范和其他工具和流程以保证代码质量和可维护性非常必要，并且这些规范和工具通常比较统一和标准化。

相比之下，后端可以使用多种编程语言和框架，例如 Java、Python、Ruby 和 Go 等等。由于后端涉及到更多复杂业务逻辑和数据处理等方面，因此后端开发更侧重于编写高效、可靠、安全且易于扩展的代码，而不像前端那样强调协同和可读性。

即使如此，在后端领域中仍存在许多针对性的工具和实践来帮助开发人员编写更好的代码。例如 Checkstyle 和 PMD 是 Java 代码检查工具，Flake8 和 Pylint 是 Python 代码检查工具，Rubocop 和 Reek 是 Ruby 代码检查工具，同时 GolangCI-Lint 和 GoMetaLinter 是针对 Go 语言的代码检查工具。

因此，无论是前端还是后端，都需要注重代码质量和可维护性，并采用最佳实践和工具来提高开发效率和团队协作能力。

总之，不同编程语言和技术栈都可以采用各种检查工具来增强代码质量和开发效率。这些工具通常可以嵌入到集成开发环境（IDE）或持续集成和部署（CI/CD）流程中，实现自动化检查和修复，进一步提高了代码的质量和可维护性。

写在最后

如果 CI 是上线前的最后一道堡垒，那么我们上面介绍的编码规范、IDE 集成各种 Lint 实际上都是倒数第二道防线，起到了辅助作用。

我们不应该完全依赖 Lint 工具来保证代码质量，而是要通过主动学习代码规范和好的代码实践，根据经验知道哪些写法是好的、哪些是不提倡的，来提高代码的可读性和健壮性。

要将代码设计得无错可查，避免浪费时间排错，这才能说明我们的代码质量真正有了提升。

因此，在使用 Lint 工具的同时，我们还需要注重自身的代码修养和经验积累，才能让代码更加健康和长久。

同时，我们还强烈推荐阅读本系列文章的另一篇《如何提升代码质量与语言学习锦囊》，以进一步拓展你的编程知识。

转载自:https://juejin.cn/post/7239715294230446137
评论
请登录