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 东西库，协助办理代码库并确保代码质量。

CI/CD 理念与实践
Go 编程格局标准（一）
Go 代码检测东西
Go 编程格局标准（二）
怎么装备 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 流程时，需求依据具体情况进行灵敏的调整和优化。

运用组件

代码保管：将代码存放在版别操控体系（如 GitHub、GitLab 等）中，完成代码同享和版别办理；
自动化构建：运用继续集成东西（如 Jenkins、Travis CI 等）对代码进行自动化构建，并生成可履行文件、库文件等；
自动化测验：运用自动化测验东西（如 JUnit、Selenium、Appium 等）对构建后的代码进行自动化测验，并生成测验报告；
静态代码剖析：运用静态代码剖析东西（如 golangci-lint、PMD、Pylint 等）对代码进行查看，以检测潜在的过错和代码质量问题；
自动化布置：运用继续交给东西（如 Spinnaker、AWS CodePipeline 等）将构建好的运用程序自动布置到测验环境或预出产环境中；
继续交给：运用自动化批阅东西（如 SonarQube、Checkmarx 等）对布置成果进行批阅，以确保交给的代码契合要求；
继续布置：运用继续布置东西（如 Kubernetes、Docker Swarm 等）将经过了一切测验和批阅的运用程序自动布置到出产环境中。

需求留意的是，在实践过程中，团队或许会挑选其他容器编列技术（如 Docker Swarm、Nomad 等）代替 Kubernetes，或许运用传统的虚拟机来进行布置。一起，Ansible 也能够与 Kubernetes 或 Docker 调配运用，用于自动化布置和装备办理。

综上所述，具体的 CI/CD 流程或许因团队规模、项目特点、技术选型等原因而有所差异。在规划和实践 CI/CD 流程时，需求依据具体情况进行灵敏的调整和优化，并在实践过程中坚持继续学习和改善的精力。

Go 编程格局标准（一）

编程格局标准主要包含两部分，其间第一部分也是最为重要的，即代码格局与标准。在这一部分中，咱们着重着重编写代码时遵从必定的格局标准和标准，以进步代码可读性、可维护性和可扩展性。当然它并不与代码质量、功用和正确性强相关。在实践中，遵从标准能够使代码愈加易于了解和修正，并有助于削减潜在的过错和安全问题。一起，不遵从标准或许会导致代码难以维护、扩展和重构，最终影响代码的质量和功用。

Go 代码标准

Effective Go（官方文档）
Go Code Review Comments（官方文档）
Uber 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 代码查看东西：

东西	阐明
`gofmt`	`Go` 标准库自带的格局化东西，用于标准化 `Go` 代码的格局和布局。
`golint`	由 `Go` 的创造者之一发布的 `Linter` 东西，可用于查看和修正 `Go` 代码中的语法过错和不标准的用法。
`go vet`	类似于编译器的静态剖析东西，可查看 `Go` 代码中的常见过错和潜在问题。
`goimports`	`Go` 言语开发中一个十分实用的东西，其主要功用是协助自动办理 `Go` 代码中的导入声明。具体来说，它能够依据必定的规矩自动增加、删去或调整导入声明。
`golangci-lint`	`Golang` 社区开发的综合性 `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 -format-only ./XXX

作用

优化前

优化后

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 提交标准

Conventional Commits（官方标准）
Commit message 和 Change log 编写指南
怎么标准你的 Git Commit Message（阿里）

约定式提交标准

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 提交样例

Good 提交样例

当然，标准化的提交代码有助于进步团队协作功率和代码质量，但关于一些开发者来说，这样写提交信息或许会感到繁琐和费事。不过幸亏，咱们能够凭借一些东西和插件来简化提交流程，甚至监督和自动化提交标准。

例如，许多编辑器或 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 东西

引荐指数：

翻开设置

Goland -> Settings -> Tools -> File Watchers

留意将 Arguments 中 ~~–disable=typecheck~~ 删掉

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

不标准的代码将被检测并提示出来

一个.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 东西

引荐指数：

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

运用 Conventional Commit 插件

引荐指数：

点评：关于频频提交代码的人来说，尽管 Conventional Commit 插件在必定程度上能够标准和便捷提交流程，但实践运用起来仍不是很便利。

Goland -> Settings -> Plugins -> Marketplace

Goland -> Settings -> Version Control -> Commit

Build Commit Message

Commit and Push

集成 commitizen 系列东西

引荐指数：

点评：想要标准化提交，的确需求凭借各种炫酷的前端 JS 库。究竟 Angular 标准已经在前端和后端开发中广泛运用，也证明了其实用性。

当然，在 Go 官方的 Contribution Guide 中，也提到了 “Good commit messages” ，咱们应该尽量遵从 Go 官方的实践。此外，还有一些质量不错的博客，如 zchee.github.io/golang-wiki… 等，能够协助咱们更好地了解和运用 Git 提交信息的标准和最佳实践。

快速装置 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

在项目根路径下履行，会生成 node_modules 依靠包目录

# 初始化JS项目
root@localhost:~# yarn
# 若全局装置，则无须再装置
root@localhost:~# yarn add -D cz-customizable cz-conventional-changelog

新建 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"
  }
}

修正 .gitignore 文件。由于这是一个 Go 项目，所以咱们能够挑选屏蔽一些 JS 东西的装备文件和依靠项。

# shield
node_modules/
.czrc
.cz-config.js
package.json
yarn.lock

假如只是想快速上手而且不需求过多定制，引荐运用 cz-conventional-changelog 库，该库能够开箱即用。

假如需求自界说提交信息格局，更引荐运用 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
}

能够创立一个 Goland 的外部东西，来便利地运用 git cz 指令。

为了愈加便利地调用，能够设置一个快捷键来履行相关操作。如：control + option + command + M

来总结下咱们的 git cz 调用方法，能够运用终端指令行、右键菜单、菜单栏等，最引荐的是运用快捷键方法（留意指令抵触）

确认没任何问题，就能够定心的提交代码了

尽管提交代码的确是一项繁琐的任务，但咱们依然主张将 “单一职责原则” 运用于提交标准中，并将其拆分为更小、逻辑上更独立的提交。此外，咱们鼓舞运用简洁明了、50 个字符以内的描绘，以更好地解说提交内容。请尽或许坚持这种形式！

装备 husky 东西

引荐指数：

点评：Husky 是构建自动化 git 提交流程中十分重要的一环！最终咱们期望完成的作用是：在运用 git 提交版别时，假如校验发现“提交描绘信息”或“更新代码文件”的内容不契合预期，就阻挠当时提交，并抛出对应的过错提示。

需求留意的是，这个和 Goland 的装备没有太大联系。在本节中，咱们只会扼要介绍完成方法，并不作为重点。假如需求更具体的信息，请自行参阅官方文档。

在项意图 .git/hooks 目录下有许多钩子，能够依据需求自界说不同的功用。其间常用的 Hooks 包含：

Git 钩子方法	调用时机	阐明
`pre-commit`	`git commit` 履行前它不承受任何参数，而且在获取提交日志音讯并进行提交之前被调用。脚本 `git commit` 以非零状态退出会导致指令在创立提交之前中止。	会在提交前被调用，而且能够按需指定是否要回绝本次提交。
`commit-msg`	`git 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	免费（短代码补全）	免费的行级代码补全东西，收费便是另一种待遇了
ChatGPT	ChatGPT Plus 会员订阅	它答应用户以对话方法与模型交互，向它提问或提示它生成呼应。这些模型能够处理更杂乱的任务。

额定弥补的话题

Goland 还有哪些运用技巧？

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 东西的一起，咱们还需求重视自身的代码涵养和经历积累，才能让代码愈加健康和持久。

一起，咱们还强烈引荐阅览本系列文章的另一篇《怎么进步代码质量与言语学习锦囊》，以进一步拓宽你的编程常识。

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