标签 Unix 下的文章

Go开发命令行程序指南

注:上面篇首配图的底图由百度文心一格生成。

本文永久链接 – https://tonybai.com/2023/03/25/the-guide-of-developing-cli-program-in-go

近期在Twitter上看到一个名为“Command Line Interface Guidelines”的站点,这个站点汇聚了帮助大家编写出更好命令行程序的哲学与指南。这份指南基于传统的Unix编程原则,又结合现代的情况进行了“与时俱进”的更新。之前我还真未就如何编写命令行交互程序做系统的梳理,在这篇文章中,我们就来结合clig这份指南,(可能不会全面覆盖)整理出一份使用Go语言编写CLI程序的指南,供大家参考。

一. 命令行程序简介

命令行接口(Command Line Interface, 简称CLI)程序是一种允许用户使用文本命令和参数与计算机系统互动的软件。开发人员编写CLI程序通常用在自动化脚本、数据处理、系统管理和其他需要低级控制和灵活性的任务上。命令行程序也是Linux/Unix管理员以及后端开发人员的最爱

2022年Q2 Go官方用户调查结果显示(如下图):在使用Go开发的程序类别上,CLI类程序排行第二,得票率60%。

之所以这样,得益于Go语言为CLI开发提供的诸多便利,比如:

  • Go语法简单而富有表现力;
  • Go拥有一个强大的标准库,并内置的并发支持;
  • Go拥有几乎最好的跨平台兼容性和快速的编译速度;
  • Go还有一个丰富的第三方软件包和工具的生态系统。

这些都让开发者使用Go创建强大和用户友好的CLI程序变得容易。

容易归容易,但要用Go编写出优秀的CLI程序,我们还需要遵循一些原则,获得一些关于Go CLI程序开发的最佳实践和惯例。这些原则和惯例涉及交互界面设计、错误处理、文档、测试和发布等主题。此外,借助于一些流行的Go CLI程序开发库和框架,比如:cobraKingpinGoreleaser等,我们可以又好又快地完成CLI程序的开发。在本文结束时,你将学会如何创建一个易于使用、可靠和可维护的Go CLI程序,你还将获得一些关于CLI开发的最佳实践和惯例的见解。

二. 建立Go开发环境

如果你读过《十分钟入门Go语言》或订阅学习过我的极客时间《Go语言第一课》专栏,你大可忽略这一节的内容。

在我们开始编写Go CLI程序之前,我们需要确保我们的系统中已经安装和配置了必要的Go工具和依赖。在本节中,我们将向你展示如何安装Go和设置你的工作空间,如何使用go mod进行依赖管理,以及如何使用go build和go install来编译和安装你的程序。

1. 安装Go

要在你的系统上安装Go,你可以遵循你所用操作系统的官方安装说明。你也可以使用软件包管理器,如homebrew(用于macOS)、chocolatey(用于Windows)或snap/apt(用于Linux)来更容易地安装Go。

一旦你安装了Go,你可以通过在终端运行以下命令来验证它是否可以正常工作。

$go version

如果安装成功,go version这个命令应该会打印出你所安装的Go的版本。比如说:

go version go1.20 darwin/amd64

2. 设置你的工作区(workspace)

Go以前有一个惯例,即在工作区目录中(\$GOPATH)组织你的代码和依赖关系。默认工作空间目录位于$HOME/go,但你可以通过设置GOPATH环境变量来改变它的路径。工作区目录包含三个子目录:src、pkg和bin。src目录包含了你的源代码文件和目录。pkg目录包含被你的代码导入的已编译好的包。bin目录包含由你的代码生成的可执行二进制文件。

Go 1.11引入Go module后,这种在\$GOPATH下组织代码和寻找依赖关系的要求被彻底取消。在这篇文章中,我依旧按照我的习惯在$HOME/go/src下放置我的代码示例。

为了给我们的CLI程序创建一个新的项目目录,我们可以在终端运行以下命令:

$mkdir -p $HOME/go/src/github.com/your-username/your-li-program
$cd $HOME/go/src/github.com/your-username/your-cli-program

注意,我们的项目目录名使用的是github的URL格式。这在Go项目中是一种常见的做法,因为它使得使用go get导入和管理依赖关系更加容易。go module成为构建标准后,这种对项目目录名的要求已经取消,但很多Gopher依旧保留了这种作法。

3. 使用go mod进行依赖管理

1.11版本后Go推荐开发者使用module来管理包的依赖关系。一个module是共享一个共同版本号和导入路径前缀的相关包的集合。一个module是由一个叫做go.mod的文件定义的,它指定了模块的名称、版本和依赖关系。

为了给我们的CLI程序创建一个新的module,我们可以在我们的项目目录下运行以下命令。

$go mod init github.com/your-username/your-cli-program

这将创建一个名为go.mod的文件,内容如下。

module github.com/your-username/your-cli-program

go 1.20

第一行指定了我们的module名称,这与我们的项目目录名称相匹配。第二行指定了构建我们的module所需的Go的最低版本。

为了给我们的模块添加依赖项,我们可以使用go get命令,加上我们想使用的软件包的导入路径和可选的版本标签。例如,如果我们想使用cobra作为我们的CLI框架,我们可以运行如下命令:

$go get github.com/spf13/cobra@v1.3.0

go get将从github下载cobra,并在我们的go.mod文件中把它作为一个依赖项添加进去。它还将创建或更新一个名为go.sum的文件,记录所有下载的module的校验和,以供后续验证使用。

我们还可以使用其他命令,如go list、go mod tidy、go mod graph等,以更方便地检查和管理我们的依赖关系。

4. 使用go build和go install来编译和安装你的程序

Go有两个命令允许你编译和安装你的程序:go build和go install。这两个命令都以一个或多个包名或导入路径作为参数,并从中产生可执行的二进制文件。

它们之间的主要区别在于它们将生成的二进制文件存储在哪里。

  • go build将它们存储在当前工作目录中。
  • go install将它们存储在\$GOPATH/bin或\$GOBIN(如果设置了)。

例如,如果我们想把CLI程序的main包(应该位于github.com/your-username/your-cli-program/cmd/your-cli-program)编译成一个可执行的二进制文件,称为your-cli-program,我们可以运行下面命令:

$go build github.com/your-username/your-cli-program/cmd/your-cli-program

$go install github.com/your-username/your-cli-program/cmd/your-cli-program@latest

三. 设计用户接口(interface)

要编写出一个好的CLI程序,最重要的环节之一是设计一个用户友好的接口。好的命令行用户接口应该是一致的、直观的和富有表现力的。在本节中,我将说明如何为命令行程序命名和选择命令结构(command structure),如何使用标志(flag)、参数(argument)、子命令(subcommand)和选项(option)作为输入参数,如何使用cobra或Kingpin等来解析和验证用户输入,以及如何遵循POSIX惯例和GNU扩展的CLI语法。

1. 命令行程序命名和命令结构选择

你的CLI程序的名字应该是简短、易记、描述性的和易输入的。它应该避免与目标平台中现有的命令或关键字发生冲突。例如,如果你正在编写一个在不同格式之间转换图像的程序,你可以把它命名为imgconv、imago、picto等,但不能叫image、convert或format。

你的CLI程序的命令结构应该反映你想提供给用户的主要功能特性。你可以选择使用下面命令结构模式中的一种:

  • 一个带有多个标志(flag)和参数(argument)的单一命令(例如:curl、tar、grep等)
  • 带有多个子命令(subcommand)的单一命令(例如:git、docker、kubectl等)
  • 具有共同前缀的多个命令(例如:aws s3、gcloud compute、az vm等)

命令结构模式的选择取决于你的程序的复杂性和使用范围,一般来说:

  • 如果你的程序只有一个主要功能或操作模式(operation mode),你可以使用带有多个标志和参数的单一命令。
  • 如果你的程序有多个相关但又不同的功能或操作模式,你可以使用一个带有多个子命令的单一命令。
  • 如果你的程序有多个不相关或独立的功能或操作模式,你可以使用具有共同前缀的多个命令。

例如,如果你正在编写一个对文件进行各种操作的程序(如复制、移动、删除),你可以任选下面命令结构模式中的一种:

  • 带有多个标志和参数的单一命令(例如,fileop -c src dst -m src dst -d src)
  • 带有多个子命令的单个命令(例如,fileop copy src dst, fileop move src dst, fileop delete src)

2. 使用标志、参数、子命令和选项

标志(flag)是以一个或多个(通常是2个)中划线(-)开头的输入参数,它可以修改CLI程序的行为或输出。例如:

$curl -s -o output.txt https://example.com

在这个例子中:

  • “-s”是一个让curl沉默的标志,即不输出执行日志到控制台;
  • “-o”是另一个标志,用于指定输出文件的名称
  • “output.txt”则是一个参数,是为“-o”标志提供的值。

参数(argument)是不以中划线(-)开头的输入参数,为你的CLI程序提供额外的信息或数据。例如:

$tar xvf archive.tar.gz

我们看在这个例子中:

  • x是一个指定提取模式的参数
  • v是一个参数,指定的是输出内容的详细(verbose)程度
  • f是另一个参数,用于指定采用的是文件模式,即将压缩结果输出到一个文件或从一个压缩文件读取数据
  • archive.tar.gz是一个参数,提供文件名。

子命令(subcommand)是输入参数,作为主命令下的辅助命令。它们通常有自己的一组标志和参数。比如下面例子:

$git commit -m "Initial commit"

我们看在这个例子中:

  • git是主命令(primary command)
  • commit是一个子命令,用于从staged的修改中创建一个新的提交(commit)
  • “-m”是commit子命令的一个标志,用于指定提交信息
  • “Initial commit”是commit子命令的一个参数,为”-m”标志提供值。

选项(option)是输入参数,它可以使用等号(=)将标志和参数合并为一个参数。例如:

$docker run --name=my-container ubuntu:latest

我们看在这个例子中“–name=my-container”是一个选项,它将容器的名称设为my-container。该选项前面的部分“–name”是一个标志,后面的部分“my-container”是参数。

3. 使用cobra包等来解析和验证用户输入的信息

如果手工来解析和验证用户输入的信息,既繁琐又容易出错。幸运的是,有许多库和框架可以帮助你在Go中解析和验证用户输入。其中最流行的是cobra

cobra是一个Go包,它提供了简单的接口来创建强大的CLI程序。它支持子命令、标志、参数、选项、环境变量和配置文件。它还能很好地与其他库集成,比如:viper(用于配置管理)、pflag(用于POSIX/GNU风格的标志)和Docopt(用于生成文档)。

另一个不那么流行但却提供了一种声明式的方法来创建优雅的CLI程序的包是Kingpin,它支持标志、参数、选项、环境变量和配置文件。它还具有自动帮助生成、命令完成、错误处理和类型转换等功能。

cobra和Kingpin在其官方网站上都有大量的文档和例子,你可以根据你的偏好和需要选择任选其一。

4. 遵循POSIX惯例和GNU扩展的CLI语法

POSIX(Portable Operating System Interface)是一套标准,定义了软件应该如何与操作系统进行交互。其中一个标准定义了CLI程序的语法和语义。GNU(GNU’s Not Unix)是一个旨在创建一个与UNIX兼容的自由软件操作系统的项目。GNU下的一个子项目是GNU Coreutils,它提供了许多常见的CLI程序,如ls、cp、mv等。

POSIX和GNU都为CLI语法建立了一些约定和扩展,许多CLI程序都采用了这些约定与扩展。下面列举了这些约定和扩展中的一些主要内容:

  • 单字母标志(single-letter flag)以一个中划线(-)开始,可以组合在一起(例如:-a -b -c 或 -abc )
  • 长标志(long flag)以两个中划线(–)开头,但不能组合在一起(例如:–all、–backup、–color )
  • 选项使用等号(=)来分隔标志名和参数值(例如:–name=my-container )
  • 参数跟在标志或选项之后,没有任何分隔符(例如:curl -o output.txt https://example.com )。
  • 子命令跟在主命令之后,没有任何分隔符(例如:git commit -m “Initial commit” )
  • 一个双中划线(–)表示标志或选项的结束和参数的开始(例如:rm — -f 表示要删除“-f”这个文件,由于双破折线的存在,这里的“-f”不再是标志)

遵循这些约定和扩展可以使你的CLI程序更加一致、直观,并与其他CLI程序兼容。然而,它们并不是强制性的,如果你有充分的理由,你也大可不必完全遵守它们。例如,一些CLI程序使用斜线(/)而不是中划线(-)表示标志(例如, robocopy /S /E src dst )。

四. 处理错误和信号

编写好的CLI程序的一个重要环节就是优雅地处理错误和信号

错误是指你的程序由于某些内部或外部因素而无法执行其预定功能的情况。信号是由操作系统或其他进程向你的程序发送的事件,以通知它一些变化或请求。在这一节中,我将说明一下如何使用log、fmt和errors包进行日志输出和错误处理,如何使用os.Exit和defer语句进行优雅的终止,如何使用os.Signal和context包进行中断和取消操作,以及如何遵循CLI程序的退出状态代码惯例。

1. 使用log、fmt和errors包进行日志记录和错误处理

Go标准库中有三个包log、fmt和errors可以帮助你进行日志和错误处理。log包提供了一个简单的接口,可以将格式化的信息写到标准输出或文件中。fmt包则提供了各种格式化字符串和值的函数。errors包提供了创建和操作错误值的函数。

要使用log包,你需要在你的代码中导入它:

import "log"

然后你可以使用log.Println、log.Printf、log.Fatal和log.Fatalf等函数来输出不同严重程度的信息。比如说:

log.Println("Starting the program...") // 打印带有时间戳的消息
log.Printf("Processing file %s...\n", filename) // 打印一个带时间戳的格式化信息
log.Fatal("Cannot open file: ", err) // 打印一个带有时间戳的错误信息并退出程序
log.Fatalf("Invalid input: %v\n", input) // 打印一个带时间戳的格式化错误信息,并退出程序。

为了使用fmt包,你需要先在你的代码中导入它:

import "fmt"

然后你可以使用fmt.Println、fmt.Printf、fmt.Sprintln、fmt.Sprintf等函数以各种方式格式化字符串和值。比如说:

fmt.Println("Hello world!") // 打印一条信息,后面加一个换行符
fmt.Printf("The answer is %d\n", 42) // 打印一条格式化的信息,后面是换行。
s := fmt.Sprintln("Hello world!") // 返回一个带有信息和换行符的字符串。
t := fmt.Sprintf("The answer is %d\n", 42) // 返回一个带有格式化信息和换行的字符串。

要使用错误包,你同样需要在你的代码中导入它:

import "errors"

然后你可以使用 errors.New、errors.Unwrap、errors.Is等函数来创建和操作错误值。比如说:

err := errors.New("Something went wrong") // 创建一个带有信息的错误值
cause := errors.Unwrap(err) // 返回错误值的基本原因(如果没有则为nil)。
match := errors.Is(err, io.EOF) // 如果一个错误值与另一个错误值匹配,则返回真(否则返回假)。

2. 使用os.Exit和defer语句实现CLI程序的优雅终止

Go有两个功能可以帮助你优雅地终止CLI程序:os.Exit和defer。os.Exit函数立即退出程序,并给出退出状态代码。defer语句则会在当前函数退出前执行一个函数调用,它常用来执行清理收尾动作,如关闭文件或释放资源。

要使用os.Exit函数,你需要在你的代码中导入os包:

import "os"

然后你可以使用os.Exit函数,它的整数参数代表退出状态代码。比如说

os.Exit(0) // 以成功的代码退出程序
os.Exit(1) // 以失败代码退出程序

要使用defer语句,你需要把它写在你想后续执行的函数调用之前。比如说

file, err := os.Open(filename) // 打开一个文件供读取。
if err != nil {
    log.Fatal(err) // 发生错误时退出程序
}
defer file.Close() // 在函数结束时关闭文件。

// 对文件做一些处理...

3. 使用os.signal和context包来实现中断和取消操作

Go有两个包可以帮助你实现中断和取消长期运行的或阻塞的操作,它们是os.signal和context包。os.signal提供了一种从操作系统或其他进程接收信号的方法。context包提供了一种跨越API边界传递取消信号和deadline的方法。

要使用os.signal,你需要先在你的代码中导入它。

import (
  "os"
  "os/signal"
)

然后你可以使用signal.Notify函数针对感兴趣的信号(如下面的os.Interrupt信号)注册一个接收channel(sig)。比如说:

sig := make(chan os.Signal, 1) // 创建一个带缓冲的信号channel。
signal.Notify(sig, os.Interrupt) // 注册sig以接收中断信号(例如Ctrl-C)。

// 做一些事情...

select {
case <-sig: // 等待来自sig channel的信号
    fmt.Println("被用户中断了")
    os.Exit(1) // 以失败代码退出程序。
default: //如果没有收到信号就执行
    fmt.Println("成功完成")
    os.Exit(0) // 以成功代码退出程序。
}

要使用上下文包,你需要在你的代码中导入它:

import "context"

然后你可以使用它的函数,如context.Background、context.WithCancel、context.WithTimeout等来创建和管理Context。Context是一个携带取消信号和deadline的对象,可以跨越API边界。比如说:

ctx := context.Background() // 创建一个空的背景上下文(从不取消)。
ctx, cancel := context.WithCancel(ctx) // 创建一个新的上下文,可以通过调用cancel函数来取消。
defer cancel() // 在函数结束前执行ctx的取消动作

// 将ctx传递给一些接受它作为参数的函数......

select {
case <-ctx.Done(): // 等待来自ctx的取消信号
    fmt.Println("Canceled by parent")
    return ctx.Err() // 从ctx返回一个错误值
default: // 如果没有收到取消信号就执行
    fmt.Println("成功完成")
    return nil // 不返回错误值
}

4. CLI程序的退出状态代码惯例

退出状态代码是一个整数,表示CLI程序是否成功执行完成。CLI程序通过调用os.Exit或从main返回的方式返回退出状态值。其他CLI程序或脚本可以可以检查这些退出状态码,并根据状态码值的不同执行不同的处理操作。

业界有一些关于退出状态代码的约定和扩展,这些约定被许多CLI程序广泛采用。其中一些主要的约定和扩展如下:。

  • 退出状态代码为0表示程序执行成功(例如:os.Exit(0) )
  • 非零的退出状态代码表示失败(例如:os.Exit(1) )。
  • 不同的非零退出状态代码可能表示不同的失败类型或原因(例如:os.Exit(2)表示使用错误,os.Exit(3)表示权限错误等等)。
  • 大于125的退出状态代码可能表示被外部信号终止(例如,os.Exit(130)为被信号中断)。

遵循这些约定和扩展可以使你的CLI程序表现的更加一致、可靠并与其他CLI程序兼容。然而,它们不是强制性的,你可以使用任何对你的程序有意义的退出状态代码。例如,一些CLI程序使用高于200的退出状态代码来表示自定义或特定应用的错误(例如,os.Exit(255)表示未知错误)。

五. 编写文档

编写优秀CLI程序的另一个重要环节是编写清晰简洁的文档,解释你的程序做什么以及如何使用它。文档可以采取各种形式,如README文件、usage信息、help flag等。在本节中,我们将告诉你如何为你的程序写一个README文件,如何为你的程序写一个有用的usage和help flag等。

1. 为你的CLI程序写一个清晰简洁的README文件

README文件是一个文本文件,它提供了关于你的程序的基本信息,如它的名称、描述、用法、安装、依赖性、许可证和联系细节等。它通常是用户或开发者在源代码库或软件包管理器上首次使用你的程序时会看到的内容。

如果你要为Go CLI程序编写一个优秀的README文件,你应该遵循一些最佳实践,比如:

  • 使用一个描述性的、醒目的标题,反映你的程序的目的和功能。
  • 提供一个简短的介绍,解释你的程序是做什么的,为什么它是有用的或独特的。
  • 包括一个usage部分,说明如何用不同的标志、参数、子命令和选项来调用你的程序。你可以使用代码块或屏幕截图来说明这些例子。
  • 包括一个安装(install)部分,解释如何在不同的平台上下载和安装你的程序。你可以使用go install、go get、goreleaser或其他工具来简化这一过程。
  • 指定你的程序的发行许可,并提供一个许可全文的链接。你可以使用SPDX标识符来表示许可证类型。
  • 为想要报告问题、请求新功能、贡献代码或提问的用户或开发者提供联系信息。你可以使用github issue、pr、discussion、电子邮件或其他渠道来达到这个目的。

以下是一个Go CLI程序的README文件的示例供参考:

2. 为你的CLI程序编写有用的usage和help标志

usage信息是一段简短的文字,总结了如何使用你的程序及其可用的标志、参数、子命令和选项。它通常在你的程序在没有参数或输入无效的情况下运行时显示。

help标志是一个特殊的标志(通常是-h或–help),它可以触发显示使用信息和一些关于你的程序的额外信息。

为了给你的Go CLI程序写有用的usage信息和help标志,你应该遵循一些准则,比如说:

  • 使用一致而简洁的语法来描述标志、参数、子命令和选项。你可以用方括号“[ ]”表示可选元素,使用角括号“< >”表示必需元素,使用省略号“…”表示重复元素,使用管道“|”表示备选,使用中划线“-”表示标志(flag),使用等号“=”表示标志的值等等。
  • 对标志、参数、子命令和选项应使用描述性的名称,以反映其含义和功能。避免使用单字母名称,除非它们非常常见或非常直观(如-v按惯例表示verbose模式)。
  • 为每个标志、参数、子命令和选项提供简短而清晰的描述,解释它们的作用以及它们如何影响你的程序的行为。你可以用圆括号“( )”来表达额外的细节或例子。
  • 使用标题或缩进将相关的标志、参数、子命令和选项组合在一起。你也可以用空行或水平线(—)来分隔usage的不同部分。
  • 在每组中按名称的字母顺序排列标志。在每组中按重要性或逻辑顺序排列参数。在每组中按使用频率排列子命令。

git的usage就是一个很好的例子:

$git
usage: git [--version] [--help] [-C <path>] [-c <name>=<value>]
           [--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]
           [-p | --paginate | -P | --no-pager] [--no-replace-objects] [--bare]
           [--git-dir=<path>] [--work-tree=<path>] [--namespace=<name>]
           <command> [<args>]

结合上面的准则,大家可以细心体会一下。

六. 测试和发布你的CLI程序

编写优秀CLI程序的最后一个环节是测试和发布你的程序。测试确保你的程序可以按预期工作,并符合质量标准。发布可以使你的程序可供用户使用和访问。

在本节中,我将说明如何使用testing、testify/assert、mock包对你的代码进行单元测试,如何使用go test、coverage、benchmark工具来运行测试和测量程序性能以及如何使用goreleaser包来构建跨平台的二进制文件。

1. 使用testing、testify的assert及mock包对你的代码进行单元测试

单元测试是一种验证单个代码单元(如函数、方法或类型)的正确性和功能的技术。单元测试可以帮助你尽早发现错误,提高代码质量和可维护性,并促进重构和调试。

要为你的Go CLI程序编写单元测试,你应该遵循一些最佳实践:

  • 使用内置的测试包来创建测试函数,以Test开头,后面是被测试的函数或方法的名称。例如:func TestSum(t *testing.T) { … };
  • 使用*testing.T类型的t参数,使用t.Error、t.Errorf、t.Fatal或t.Fatalf这样的方法报告测试失败。你也可以使用t.Log、t.Logf、t.Skip或t.Skipf这样的方法来提供额外的信息或有条件地跳过测试。
  • 使用Go子测试(sub test),通过t.Run方法将相关的测试分组。例如:
func TestSum(t *testing.T) {
    t.Run("positive numbers", func(t *testing.T) {
        // test sum with positive numbers
    })
    t.Run("negative numbers", func(t *testing.T) {
        // test sum with negative numbers
    })
}
  • 使用表格驱动(table-driven)的测试来运行多个测试用例,比如下面的例子:
func TestSum(t *testing.T) {
    tests := []struct{
        name string
        a int
        b int
        want int
    }{
        {"positive numbers", 1, 2, 3},
        {"negative numbers", -1, -2, -3},
        {"zero", 0, 0 ,0},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := Sum(tt.a , tt.b)
            if got != tt.want {
                t.Errorf("Sum(%d , %d) = %d; want %d", tt.a , tt.b , got , tt.want)
            }
        })
    }
}
  • 使用外部包,如testify/assert或mock来简化你的断言或对外部的依赖性。比如说:
import (
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
)

type Calculator interface {
    Sum(a int , b int) int
}

type MockCalculator struct {
    mock.Mock
}

func (m *MockCalculator) Sum(a int , b int) int {
    args := m.Called(a , b)
    return args.Int(0)
}

2. 使用Go的测试、覆盖率、性能基准工具来运行测试和测量性能

Go提供了一套工具来运行测试和测量你的代码的性能。你可以使用这些工具来确保你的代码按预期工作,检测错误或bug,并优化你的代码以提高速度和效率。

要使用go test、coverage、benchmark工具来运行测试和测量你的Go CLI程序的性能,你应该遵循一些步骤,比如说。

  • 将以_test.go结尾的测试文件写在与被测试代码相同的包中。例如:sum_test.go用于测试sum.go。
  • 使用go测试命令来运行一个包中的所有测试或某个特定的测试文件。你也可以使用一些标志,如-v,用于显示verbose的输出,-run用于按名字过滤测试用例,-cover用于显示代码覆盖率,等等。例如:go test -v -cover ./…
  • 使用go工具cover命令来生成代码覆盖率的HTML报告,并高亮显示代码行。你也可以使用-func这样的标志来显示函数的代码覆盖率,用-html还可以在浏览器中打开覆盖率结果报告等等。例如:go tool cover -html=coverage.out
  • 编写性能基准函数,以Benchmark开头,后面是被测试的函数或方法的名称。使用类型为*testing.B的参数b来控制迭代次数,并使用b.N、b.ReportAllocs等方法控制报告结果的输出。比如说
func BenchmarkSum(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Sum(1 , 2)
    }
}
  • 使用go test -bench命令来运行一个包中的所有性能基准测试或某个特定的基准文件。你也可以使用-benchmem这样的标志来显示内存分配的统计数据,-cpuprofile或-memprofile来生成CPU或内存profile文件等等。例如:go test -bench . -benchmem ./…

  • 使用pprof或benchstat等工具来分析和比较CPU或内存profile文件或基准测试结果。比如说。

# Generate CPU profile
go test -cpuprofile cpu.out ./...

# Analyze CPU profile using pprof
go tool pprof cpu.out

# Generate two sets of benchmark results
go test -bench . ./... > old.txt
go test -bench . ./... > new.txt

# Compare benchmark results using benchstat
benchstat old.txt new.txt

3. 使用goreleaser包构建跨平台的二进制文件

构建跨平台二进制文件意味着将你的代码编译成可执行文件,可以在不同的操作系统和架构上运行,如Windows、Linux、Mac OS、ARM等。这可以帮助你向更多的人分发你的程序,使用户更容易安装和运行你的程序而不需要任何依赖或配置。

为了给你的Go CLI程序建立跨平台的二进制文件,你可以使用外部软件包,比如goreleaser等 ,它们可以自动完成程序的构建、打包和发布过程。下面是使用goreleaser包构建程序的一些步骤。

  • 使用go get或go install命令安装goreleaser。例如: go install github.com/goreleaser/goreleaser@latest
  • 创建一个配置文件(通常是.goreleaser.yml),指定如何构建和打包你的程序。你可以定制各种选项,如二进制名称、版本、主文件、输出格式、目标平台、压缩、校验和、签名等。例如。
# .goreleaser.yml
project_name: mycli
builds:
  - main: ./cmd/mycli/main.go
    binary: mycli
    goos:
      - windows
      - darwin
      - linux
    goarch:
      - amd64
      - arm64
archives:
  - format: zip
    name_template: "{{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}"
    files:
      - LICENSE.txt
      - README.md
checksum:
  name_template: "{{ .ProjectName }}_checksums.txt"
  algorithm: sha256

运行goreleaser命令,根据配置文件构建和打包你的程序。你也可以使用-snapshot用于测试,-release-notes用于从提交信息中生成发布说明,-rm-dist用于删除之前的构建,等等。例如:goreleaser –snapshot –rm-dist。

检查输出文件夹(通常是dist)中生成的二进制文件和其他文件。你也可以使用goreleaser的发布功能将它们上传到源代码库或软件包管理器中。

七. clig.dev指南要点

通过上述的系统说明,你现在应该可以设计并使用Go实现出一个CLI程序了。不过本文并非覆盖了clig.dev指南的所有要点,因此,在结束本文之前,我们再来回顾一下clig.dev指南中的要点,大家再体会一下。

前面说过,clig.dev上的cli指南是一个开源指南,可以帮助你写出更好的命令行程序,它采用了传统的UNIX原则,并针对现代的情况进行了更新。

遵循cli准则的一些好处是:

  • 你可以创建易于使用、理解和记忆的CLI程序。
  • 你可以设计出能与其他程序进行很好配合的CLI程序,并遵循共同的惯例。
  • 你可以避免让用户和开发者感到沮丧的常见陷阱和错误。
  • 你可以从其他CLI设计者和用户的经验和智慧中学习。

下面是该指南的一些要点:

  • 理念

这一部分解释了好的CLI设计背后的核心原则,如人本设计、可组合性、可发现性、对话性等。例如,以人为本的设计意味着CLI程序对人类来说应该易于使用和理解,而不仅仅是机器。可组合性意味着CLI程序应该通过遵循共同的惯例和标准与其他程序很好地协作。

  • 参数和标志

这一部分讲述了如何在你的CLI程序中使用位置参数(positional arguments )和标志。它还解释了如何处理默认值、必传参数、布尔标志、多值等。例如,你应该对命令的主要对象或动作使用位置参数,对修改或可选参数使用标志。你还应该使用长短两种形式的标志(如-v或-verbose),并遵循常见的命名模式(如–help或–version)。

  • 配置

这部分介绍了如何使用配置文件和环境变量来为你的CLI程序存储持久的设置。它还解释了如何处理配置选项的优先级、验证、文档等。例如,你应该使用配置文件来处理用户很少改变的设置,或者是针对某个项目或环境的设置。对于特定于环境或会话的设置(如凭证或路径),你也应该使用环境变量。

  • 输出

这部分介绍了如何格式化和展示你的CLI程序的输出。它还解释了如何处理输出verbose级别、进度指示器、颜色、表格等。例如,你应该使用标准输出(stdout)进行正常的输出,这样输出的信息可以通过管道输送到其他程序或文件。你还应该使用标准错误(stderr)来处理不属于正常输出流的错误或警告。

  • 错误

这部分介绍了如何在你的CLI程序中优雅地处理错误。它还解释了如何使用退出状态码、错误信息、堆栈跟踪等。例如,你应该使用表明错误类型的退出代码(如0代表成功,1代表一般错误)。你还应该使用简洁明了的错误信息,解释出错的原因以及如何解决。

  • 子命令

这部分介绍了当CLI程序有多种操作或操作模式时,如何在CLI程序中使用子命令。它还解释了如何分层构建子命令,组织帮助文本,以及处理常见的子命令(如help或version)。例如,当你的程序有不同的功能,需要不同的参数或标志时(如git clone或git commit),你应该使用子命令。你还应该提供一个默认的子命令,或者在没有给出子命令时提供一个可用的子命令列表。

业界有许多精心设计的CLI工具的例子,它们都遵循cli准则,大家可以通过使用来深刻体会一下这些准则。下面是一些这样的CLI工具的例子:

  • httpie:一个命令行HTTP客户端,具有直观的UI,支持JSON,语法高亮,类似wget的下载,插件等功能。例如,Httpie使用清晰简洁的语法进行HTTP请求,支持多种输出格式和颜色,优雅地处理错误并提供有用的文档。

  • git:一个分布式的版本控制系统,让你管理你的源代码并与其他开发者合作。例如,Git使用子命令进行不同的操作(如git clone或git commit),遵循通用的标志(如-v或-verbose),提供有用的反馈和建议(如git status或git help),并支持配置文件和环境变量。

  • npm:一个JavaScript的包管理器,让你为你的项目安装和管理依赖性。例如,NPM使用一个简单的命令结构(npm [args]),提供一个简洁的初始帮助信息,有更详细的选项(npm help npm),支持标签完成和合理的默认值,并允许你通过配置文件(.npmrc)自定义设置。

八. 小结

在这篇文章中,我们系统说明了如何编写出遵循命令行接口指南的Go CLI程序。

你学习了如何设置Go环境、设计命令行接口、处理错误和信号、编写文档、使用各种工具和软件包测试和发布程序。你还看到了一些代码和配置文件的例子。通过遵循这些准则和最佳实践,你可以创建一个用户友好、健壮和可靠的CLI程序。

最后我们回顾了clig.dev的指南要点,希望你能更深刻理解这些要点的含义。

我希望你喜欢这篇文章并认为它很有用。如果你有任何问题或反馈,请随时联系我。编码愉快!

注:本文系与New Bing Chat联合完成,旨在验证如何基于AIGC能力构思和编写长篇文章。文章内容的正确性经过笔者全面审校,可放心阅读。


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

Go程序员拥抱C语言简明指南

本文永久链接 – https://tonybai.com/2022/05/16/the-short-guide-of-embracing-c-lang-for-gopher

本文是为于航老师的极客时间专栏《深入C语言和程序运行原理》写的加餐文章《Tony Bai:Go程序员拥抱C语言简明指南》,这里分享给大家,尤其是那些想学习C语言的Gopher们。


你好,我是Tony Bai。

也许有同学对我比较熟悉,看过我在极客时间上的专栏《Tony Bai ·Go语言第一课》,或者是关注了我的博客。那么,作为一个Gopher,我怎么跑到这个C语言专栏做分享了呢?其实,在学习Go语言并成为一名Go程序员之前,我也曾是一名地地道道的C语言程序员。

大学毕业后,我就开始从事C语言后端服务开发工作,在电信增值领域摸爬滚打了十多年。不信的话,你可以去翻翻我的博客,数一数我发的C语言相关文章是不是比关于Go的还多。一直到近几年,我才将工作中的主力语言从C切换到了Go。不过这并不是C语言的问题,主要原因是我转换赛道了。我目前在智能网联汽车领域从事面向云原生平台的先行研发,而在云原生方面,新生代的Go语言有着更好的生态。

不过作为资深C程序员,C语言已经在我身上打下了深深的烙印。虽然Go是我现在工作中的主力语言,但我仍然会每天阅读一些C开源项目的源码,每周还会写下数百行的C代码。在一些工作场景中,特别是在我参与先行研发一些车端中间件时,C语言有着资源占用小、性能高的优势,这一点是Go目前还无法匹敌的。

正因为我有着C程序员和Go程序员的双重身份,接到这个加餐邀请时,我就想到了一个很适合聊的话题——在 Gopher(泛指Go程序员)与C语言之间“牵线搭桥”。在这门课的评论区里,我看到一些同学说,“正是因为学了Go,所以我想学好C”。如果你也对Go比较熟悉,那么恭喜你,这篇加餐简直是为你量身定制的:一个熟悉Go的程序员在学习C时需要注意的问题,还有可能会遇到的坑,我都替你总结好了。

当然,我知道还有一些对Go了解不多的同学,看到这里也别急着退出去。因为C和Go这两门语言的比较,本身就是一个很有意思的话题。今天的加餐,会涉及这两门语言的异同点,通过对C与Go语言特性的比较,你就能更好地理解“C 语言为什么设计成现在这样”。

一. C语言是现代IT工业的根基

在比较C和Go之前,先说说我推荐Gopher学C的最重要原因吧:用一句话总结,C语言在IT工业中的根基地位,是Go和其他语言目前都无法动摇的

C语言是由美国贝尔实验室的丹尼斯·里奇(Dennis Ritchie)以Unix发明人肯·汤普森(Ken Thompson)设计的B语言为基础而创建的高级编程语言。诞生于上个世纪(精确来说是1972年)的它,到今年(2022年)已到了“知天命”的半百年纪。 年纪大、设计久远一直是“C语言过时论”兴起的根源,但如果你相信这一论断,那就大错特错了。下面,我来为你分析下个中缘由。

首先,我们说说C语言本身:C语言一直在演进,从未停下过脚步

虽然C语言之父丹尼斯·里奇不幸于2011年永远地离开了我们,但C语言早已成为ANSI(美国国家标准学会)标准以及ISO/IEC(国际标准化组织和国际电工委员会)标准,因此其演进也早已由标准委员会负责。我们来简单回顾一下C语言标准的演进过程:

  • 1989年,ANSI发布了首个C语言标准,被称为C89,又称ANSI C。次年,ISO和IEC把ANSI C89标准定为C语言的国际标准(ISO/IEC 9899:1990),又称C90,它也是C语言的第一个官方版本;
  • 1999年,ISO和IEC发布了C99标准(ISO/IEC 9899:1999),它是C语言的第二个官方版本;
  • 2011年,ISO和IEC发布了C11标准(ISO/IEC 9899:2011),它是C语言的第三个官方版本;
  • 2018年,ISO和IEC发布了C18标准(ISO/IEC 9899:2018),它是C语言的第四个官方版本。
    目前,ISO/IEC标准化委员会正在致力于C2x标准的改进与制定,预计它会在2023年发布。

其次,时至今日,C语言的流行度仍然非常高

著名编程语言排行榜TIOBE的数据显示,各大编程语言年度平均排名的总位次,C语言多年来高居第一,如下图(图片来自TIOBE)所示:

这说明,无论是在过去还是现在,C语言都是一门被广泛应用的工业级编程语言。

最后,也是最重要的一点是:C语言是现代IT工业的根基,我们说C永远不会退出IT行业舞台也不为过。

如今,无论是普通消费者端的Windows、macOS、Android、苹果iOS,还是服务器端的Linux、Unix等操作系统,亦或是各个工业嵌入式领域的操作系统,其内核实现语言都是C语言。互联网时代所使用的主流Web服务器,比如 Nginx、Apache,以及主流数据库,比如MySQL、Oracle、PostgreSQL等,也都是使用C语言开发的杰作。可以说,现代人类每天都在跟由C语言实现的系统亲密接触,并且已经离不开这些系统了。回到我们程序员的日常,Git、SVN等我们时刻在用的源码版本控制软件也都是由C语言实现的。

可以说,C语言在IT工业中的根基地位,不光Go语言替代不了,C++、Rust等系统编程语言也无法动摇,而且不仅短期如此,长期来看也是如此。

总之,C语言具有紧凑、高效、移植性好、对内存的精细控制等优秀特性,这使得我们在任何时候学习它都不会过时。不过,我在这里推荐Gopher去了解和系统学习C语言,其实还有另一个原因。我们继续往下看。

二. C与Go的相通之处:Gopher拥抱C语言的“先天优势”

众所周知,Go 是在C语言的基础上衍生而来的,二者之间有很多相通之处,因此 Gopher 在学习C语言时是有“先天优势”的。接下来,我们具体看看C和Go的相通之处有哪些。

1. 简单且语法同源

Go语言以简单著称,而作为Go先祖的C语言,入门门槛同样不高:Go有25个关键字,C有32个关键字(C89标准),简洁程度在伯仲之间。C语言曾长期作为高校计算机编程教育的首选编程语言,这与C的简单也不无关系。

和Go不同的是,C语言是一个小内核、大外延的编程语言,其简单主要体现在小内核上了。这个“小内核”包括C基本语法与其标准库,我们可以快速掌握它。但需要注意的是,与Go语言“开箱即用、内容丰富”的标准库不同,C标准库非常小(在C11标准之前甚至连thread库都不包含),所以掌握“小内核”后,在LeetCode平台上刷题是没有任何问题的,但要写出某一领域的工业级生产程序,我们还有很多外延知识技能要学习,比如并发原语、操作系统的系统调用,以及进程间通信等。

C语言的这种简单很容易获得Gopher们的认同感。当年Go语言之父们在设计Go语言时,也是主要借鉴了C语言的语法。当然,这与他们深厚的C语言背景不无关系:肯·汤普森(Ken Thompson)是Unix之父,与丹尼斯·里奇共同设计了C语言;罗博·派克(Rob Pike)是贝尔实验室的资深研究员,参与了Unix系统的演进、Plan9操作系统的开发,还是UTF-8编码的发明人;罗伯特·格瑞史莫(Robert Griesemer)也是用C语言手写Java虚拟机的大神级人物。

Go的第一版编译器就是由肯·汤普森(Ken Thompson)用C语言实现的。并且,Go语言的早期版本中,C代码的比例还不小。以Go语言发布的第一个版本,Go 1.0版本为例,我们通过loccount工具对其进行分析,会得到下面的结果:

$loccount .
all          SLOC=460992  (100.00%) LLOC=193045  in 2746 files
Go           SLOC=256321  (55.60%)  LLOC=109763  in 1983 files
C            SLOC=148001  (32.10%)  LLOC=73458   in 368 files
HTML         SLOC=25080   (5.44%)   LLOC=0       in 57 files
asm          SLOC=10109   (2.19%)   LLOC=0       in 133 files
... ...

这里我们看到,在1.0版本中,C语言代码行数占据了32.10%的份额,这一份额直至Go 1.5版本实现自举后,才下降为不到1%。

我当初对Go“一见钟情”,其中一个主要原因就是Go与C语言的语法同源。相对应地,相信这种同源的语法也会让Gopher们喜欢上C语言。

2. 静态编译且基础范式相同

除了语法同源,C语言与Go语言的另一个相同点是,它们都是静态编译型语言。这意味着它们都有如下的语法特性:

  • 变量与函数都要先声明后才能使用;
  • 所有分配的内存块都要有对应的类型信息,并且在确定其类型信息后才能操作;
  • 源码需要先编译链接后才能运行。

相似的编程逻辑与构建过程,让学习C语言的Gopher可以做到无缝衔接。

除此之外,Go 和C的基础编程范式都是命令式编程(imperative programming),即面向算法过程,由程序员通过编程告诉计算机应采取的动作。然后,计算机按程序指令执行一系列流程,生成特定的结果,就像菜谱指定了厨师做蛋糕时应遵循的一系列步骤一样。

从Go看 C,没有面向对象,没有函数式编程,没有泛型(Go 1.18已加入),满眼都是类型与函数,可以说是相当亲切了。

3. 错误处理机制如出一辙

对于后端编程语言来说,错误处理机制十分重要。如果两种语言的错误处理机制不同,那么这两种语言的代码整体语法风格很可能大不相同。

在C语言中,我们通常用一个类型为整型的函数返回值作为错误状态标识,函数调用者基于值比较的方式,对这一代表错误状态的返回值进行检视。通常,当这个返回值为0时,代表函数调用成功;当这个返回值为其他值时,代表函数调用出现错误。函数调用者需根据该返回值所代表的错误状态,来决定后续执行哪条错误处理路径上的代码。

C语言这种简单的基于错误值比较的错误处理机制,让每个开发人员必须显式地去关注和处理每个错误。经过显式错误处理的代码会更为健壮,也会让开发人员对这些代码更有信心。另外,这些错误就是普通的值,我们不需要额外的语言机制去处理它们,只需利用已有的语言机制,像处理其他普通类型值那样去处理错误就可以了。这让代码更容易调试,我们也更容易针对每个错误处理的决策分支进行测试覆盖。

C语言错误处理机制的这种简单与显式,跟Go语言的设计哲学十分契合,于是Go语言设计者决定继承这种错误处理机制。因此,当Gopher们来到C语言的世界时,无需对自己的错误处理思维做出很大的改变,就可以很容易地适应C语言的风格。

三. 知己知彼,来看看C与Go的差异

虽说 Gopher 学习C语言有“先天优势”,但是不经过脚踏实地的学习与实践就想掌握和精通C语言,也是不可能的。而且,C 和Go还是有很大差异的,Gopher 们只有清楚这些差异,做到“知己知彼”,才能在学习过程中分清轻重,有的放矢。俗话说,“磨刀不误砍柴功”,下面我们就一起看看C与Go有哪些不同。

1. 设计哲学

在人类自然语言学界,有一个很著名的假说——“萨丕尔-沃夫假说”。这个假说的内容是这样的:语言影响或决定人类的思维方式。对我来说,编程语言也不仅仅是一门工具,它还影响着程序员的思维方式。每次开始学习一门新的编程语言时,我都会先了解这门编程语言的设计哲学。

每种编程语言都有自己的设计哲学,即便这门语言的设计者没有将其显式地总结出来,它也真真切切地存在,并影响着这门语言的后续演进,以及这门语言程序员的思维方式。我在《Tony Bai · Go语言第一课》专栏里,将Go语言的设计哲学总结成了5点,分别是简单、显式、组合、并发和面向工程

那么C语言的设计哲学又是什么呢?从表面上看,简单紧凑、性能至上、极致资源、全面移植,这些都可以作为C的设计哲学,但我倾向于一种更有人文气息的说法:满足和相信程序员

在这样的设计哲学下,一方面,C语言提供了几乎所有可以帮助程序员表达自己意图的语法手段,比如宏、指针与指针运算、位操作、pragma指示符、goto语句,以及跳转能力更为强大的longjmp等;另一方面,C语言对程序员的行为并没有做特别严格的限定与约束,C程序员可以利用语言提供的这些语法手段,进行天马行空的发挥:访问硬件、利用指针访问内存中的任一字节、操控任意字节中的每个位(bit)等。总之,C语言假定程序员知道他们在做什么,并选择相信程序员。

C语言给了程序员足够的自由,可以说,在C语言世界,你几乎可以“为所欲为”。但这种哲学也是有代价的,那就是你可能会犯一些莫名其妙的错误,比如悬挂指针,而这些错误很少或不可能在其他语言中出现。

这里再用一个比喻来更为形象地表达下:从Go世界到C世界,就好比在动物园中饲养已久的动物被放归到野生自然保护区,有了更多自由,但周围也暗藏着很多未曾遇到过的危险。因此,学习C语言的Gopher们要有足够的心理准备。

2. 内存管理

接下来我们来看C与Go在内存管理方面的不同。我把这一点放在第二位,是因为这两种语言在内存管理上有很大的差异,而且这一差异会给程序员的日常编码带来巨大影响。

我们知道,Go是带有垃圾回收机制(俗称GC)的静态编程语言。使用Go编程时,内存申请与释放,在栈上还是在堆上分配,以及新内存块的清零等等,这一切都是自动的,且对程序员透明。

但在C语言中,上面说的这些都是程序员的责任。手工内存管理在带来灵活性的同时,也带来了极大的风险,其中最常见的就是内存泄露(memory leak)与悬挂指针(dangling pointer)问题。

内存泄露主要指的是程序员手工在堆上分配的内存在使用后没有被释放(free),进而导致的堆内存持续增加。而悬挂指针的意思是指针指向了非法的内存地址,未初始化的指针、指针所指对象已经被释放等,都是导致悬挂指针的主要原因。针对悬挂指针进行解引用(dereference)操作将会导致运行时错误,从而导致程序异常退出的严重后果。

Go语言带有GC,而C语言不带GC,这都是由各自语言设计哲学所决定的。GC是不符合C语言的设计哲学的,因为一旦有了GC,程序员就远离了机器,程序员直面机器的需求就无法得到满足了。并且,一旦有了GC,无论是在性能上还是在资源占用上,都不可能做到极致了。

在C中,手工管理内存到底是一种什么感觉呢?作为一名有着十多年C开发经验的资深C程序员,我只能告诉你:与内存斗,其乐无穷!这是在带GC的编程语言中无法体会到的。

3. 语法形式

虽然C语言是Go的先祖,并且Go也继承了很多C语言的语法元素,但在变量/函数声明、行尾分号、代码块是否用括号括起、标识符作用域,以及控制语句语义等方面,二者仍有较大差异。因此,对Go已经很熟悉的程序员在初学C时,受之前编码习惯的影响,往往会踩一些“坑”。基于此,我总结了Gopher学习C语言时需要特别注意的几点,接下来我们具体看看。

第一,注意声明变量时类型与变量名的顺序

前面说过,Go与C都是静态编译型语言,这就要求我们在使用任何变量之前,需要先声明这个变量。但Go采用的变量声明语法颇似Pascal语言,即变量名在前,变量类型在后,这与C语言恰好相反,如下所示:

Go:

var a, b int
var p, q *int

vs.

C:
int a, b;
int *p, *q;

此外,Go支持短变量声明,并且由于短变量声明更短小,无需显式提供变量类型,Go编译器会根据赋值操作符后面的初始化表达式的结果,自动为变量赋予适当类型。因此,它成为了Gopher们喜爱和重度使用的语法。但短声明在C中却不是合法的语法元素:

int main() {
    a := 5; //  error: expected expression
    printf("a = %d\n", a);
}

不过,和上面的变量类型与变量名声明的顺序问题一样,C编译器会发现并告知我们这个问题,并不会给程序带来实质性的伤害。

第二,注意函数声明无需关键字前缀

无论是C语言还是Go语言,函数都是基本功能逻辑单元,我们也可以说C程序就是一组函数的集合。实际上,我们日常的C代码编写大多集中在实现某个函数上。

和变量一样,函数在两种语言中都需要先声明才能使用。Go语言使用func关键字作为函数声明的前缀,并且函数返回值列表放在函数声明的最后。但在C语言中,函数声明无需任何关键字作为前缀,函数只支持单一返回值,并且返回值类型放在函数名的前面,如下所示:

Go:
func Add(a, b int) int {
    return a+b
}

vs.

C:
int Add(int a, int b) {
    return a+b;
}

第三,记得加上代码行结尾的分号

我们日常编写Go代码时,极少手写分号。这是因为,Go设计者当初为了简化代码编写,提高代码可读性,选择了由编译器在词法分析阶段自动在适当位置插入分号的技术路线。如果你是一个被Go编译器惯坏了的Gopher,来到C语言的世界后,一定不要忘记代码行尾的分号。比如上面例子中的C语言Add函数实现,在return语句后面记得要手动加上分号。

第四,补上“省略”的括号

同样是出于简化代码、增加可读性的考虑,Go设计者最初就取消掉了条件分支语句(if)、选择分支语句(switch)和循环控制语句(for)中条件表达式外围的小括号:

// Go代码
func f() int {
    return 5
}
func main() {
    a := 1
    if a == 1 { // 无需小括号包裹条件表达式
        fmt.Println(a)
    }

    switch b := f(); b { // 无需小括号包裹条件表达式
    case 4:
        fmt.Println("b = 4")
    case 5:
        fmt.Println("b = 5")
    default:
        fmt.Println("b = n/a")
    }

    for i := 1; i < 10; i++ { // 无需小括号包裹循环语句的循环表达式
        a += i
    }
    fmt.Println(a)
}

这一点恰恰与C语言“背道而驰”。因此,我们在使用C语言编写代码时,务必要想着补上这些括号:

// C代码
int f() {
        return 5;
}

int main() {
    int a = 1;
    if (a == 1) { // 需用小括号包裹条件表达式
        printf("%d\n", a);
    }

    int b = f();
    switch (b) { // 需用小括号包裹条件表达式
    case 4:
        printf("b = 4\n");
        break;
    case 5:
        printf("b = 5\n");
        break;
    default:
        printf("b = n/a\n");
    }

    int i = 0;
    for (i = 1; i < 10; i++) { // 需用小括号包裹循环语句的循环表达式
        a += i;
    }
    printf("%d\n", a);
}

第五,留意C与Go导出符号的不同机制

C语言通过头文件来声明对外可见的符号,所以我们不用管符号是不是首字母大写的。但在Go中,只有首字母大写的包级变量、常量、类型、函数、方法才是可导出的,即对外部包可见。反之,首字母小写的则为包私有的,仅在包内使用。Gopher一旦习惯了这样的规则,在切换到C语言时,就会产生“心理后遗症”:遇到在其他头文件中定义的首字母小写的函数时,总以为不能直接使用。

第六,记得在switch case语句中添加break

C 语言与Go语言在选择分支语句的语义方面有所不同:C语言的 case 语句中,如果没有显式加入break语句,那么代码将向下自动掉落执行。而Go在最初设计时就重新规定了switch case的语义,默认不自动掉落(fallthrough),除非开发者显式使用fallthrough关键字。

适应了Go的switch case语句的语义后再回来写C代码,就会存在潜在的“风险”。我们来看一个例子:

// C代码:
int main() {
    int a = 1;
    switch(a) {
        case 1:printf("a = 1\n");
        case 2:printf("a = 2\n");
        case 3:printf("a = 3\n");
        default:printf("a = ?\n");
    }
}

这段代码是按Go语义编写的switch case,编译运行后得到的结果如下:

a = 1
a = 2
a = 3
a = ?

这显然不符合我们输出“a = 1”的预期。对于初学C的Gopher而言,这个问题影响还是蛮大的,因为这样编写的代码在C编译器眼中是完全合法的,但所代表的语义却完全不是开发人员想要的。这样的程序一旦流入到生产环境,其缺陷可能会引发生产故障。

一些Clint 工具可以检测出这样的问题,因此对于写C代码的Gopher,我建议在提交代码前使用lint工具对代码做一下检查。

4. 构建机制

Go与C都是静态编译型语言,它们的源码需要经过编译器和链接器处理,这个过程称为构建(build),构建后得到的可执行文件才是最终交付给用户的成果物。

和Go语言略有不同的是,C语言的构建还有一个预处理(pre-processing)阶段,预处理环节的输出才是C编译器的真正输入。C语言中的宏就是在预处理阶段展开的。不过,Go没有预处理阶段。

C语言的编译单元是一个C源文件(.c),每个编译单元在编译过程中会对应生成一个目标文件(.o/.obj),最后链接器将这些目标文件链接在一起,形成可执行文件。

而Go则是以一个包(package)为编译单元的,每个包内的源文件生成一个.o文件,一个包的所有.o文件聚合(archive)成一个.a文件,链接器将这些目标文件链接在一起形成可执行文件。

Go语言提供了统一的Go命令行工具链,且Go编译器原生支持增量构建,源码构建过程不需要Gopher手工做什么配置。但在C语言的世界中,用于构建C程序的工具有很多,主流的包括gcc/clang,以及微软平台的C编译器。这些编译器原生不支持增量构建,为了提升工程级构建的效率,避免每次都进行全量构建,我们通常会使用第三方的构建管理工具,比如make(Makefile)或CMake。考虑移植性时,我们还会使用到configure文件,用于在目标机器上收集和设置编译器所需的环境信息。

5. 依赖管理

我在前面提过,C语言仅提供了一个“小内核”。像依赖管理这类的事情,C语言本身并没有提供跟Go中的Go Module类似的,统一且相对完善的解决方案。在C语言的世界中,我们依然要靠外部工具(比如CMake)来管理第三方的依赖。

C语言的第三方依赖通常以静态库(.a)或动态共享库(.so)的形式存在。如果你的应用要使用静态链接,那就必须在系统中为C编译器提供第三方依赖的静态库文件。但在实际工作中,完全采用静态链接有时是会遇到麻烦的。这是因为,很多操作系统在默认安装时是不带开发包的,也就是说,像 libc、libpthread 这样的系统库只提供了动态共享库版本(如/lib下提供了libc的共享库libc.so.6),其静态库版本是需要自行下载、编译和安装的(如libc的静态库libc.a在安装后是放在/usr/lib下面的)。所以多数情况下,我们是将****静态、动态****两种链接方式混合在一起使用的,比如像libc这样的系统库多采用动态链接。

动态共享库通常是有版本的,并且按照一定规则安装到系统中。举个例子,一个名为libfoo的动态共享库,在安装的目录下文件集合通常是这样:

2022-03-10 12:28 libfoo.so -> libfoo.so.0.0.0*
2022-03-10 12:28 libfoo.so.0 -> libfoo.so.0.0.0*
2022-03-10 12:28 libfoo.so.0.0.0*

按惯例,每个动态共享库都有多个名字属性,包括real name、soname和linker name。下面我们来分别看下。

  • real name:实际包含共享库代码的那个文件的名字(如上面例子中的libfoo.so.0.0.0)。动态共享库的真实版本信息就在real name中,显然real name中的版本号符合语义版本规范,即major.minor.patch。当两个版本的major号一致,说明是向后兼容的两个版本;
  • soname:shared object name的缩写,也是这三个名字中最重要的一个。无论是在编译阶段还是在运行阶段,系统链接器都是通过动态共享库的soname(如上面例子中的libfoo.so.0)来唯一识别共享库的。我们看到的soname实际上是仅包含major号的共享库名字;
  • linker name:编译阶段提供给编译器的名字(如上面例子中的libfoo.so)。如果你构建的共享库的real name跟上面例子中libfoo.so.0.0.0类似,带有版本号,那么你在编译器命令中直接使用-L path -lfoo是无法让链接器找到对应的共享库文件的,除非你为libfoo.so.0.0.0提供了一个linker name(如libfoo.so,一个指向libfoo.so.0.0.0的符号链接)。linker name一般在共享库安装时手工创建。
    动态共享库有了这三个名称属性,依赖管理就有了依据。但由于在链接的时候使用的是linker name,而linker name并不带有版本号,真实版本与主机环境有关,因此要实现C应用的可重现构建还是比较难。在实践中,我们通常会使用专门的构建主机,项目组将该主机上的依赖管理起来,进而保证每次构建所使用的依赖版本是可控的。同时,应用部署的目标主机上的依赖版本也应该得到管理,避免运行时出现动态共享库版本不匹配的问题。

6. 代码风格

Go语言是历史上首次实现了代码风格全社区统一的编程语言。它基本上消除了开发人员在代码风格上的无休止的、始终无法达成一致的争论,以及不同代码风格带来的阅读、维护他人代码时的低效。gofmt工具格式化出来的代码风格已经成为Go开发者的一种共识,融入到Go语言的开发文化当中了。所以,如果你让某个Go开发者说说gofmt后的代码风格是什么样的,多数Go开发者可能说不出,因为代码会被gofmt自动变成那种风格,大家已经不再关心风格了。

而在C语言的世界,代码风格仍存争议。但经过多年的演进,以及像Go这样新兴语言的不断“教育”,C社区也在尝试进行这方面的改进,涌现出了像clang-format这样的工具。目前,虽然还没有在全社区达成一致的代码风格(由于历史原因,这很难做到),但已经可以减少很多不必要的争论。

对于正在学习C语言,并进行C编码实践的Gopher,我的建议是:不要拘泥于使用什么代码风格,先用clang-format,并确定一套风格模板就好

四. 小结

作为一名对Go跟随和研究了近十年的程序员,我深刻体会到,Go的简单性、性能和生产力使它成为了创建面向用户的应用程序和服务的理想语言。快速的迭代让团队能够快速地作出反应,以满足用户不断变化的需求,让团队可以将更多精力集中在保持灵活性上。

但Go也有缺点,比如缺少对内存以及一些低级操作的精确控制,而C语言恰好可以弥补这个缺陷。C 语言提供的更精细的控制允许更多的精确性,使得C成为低级操作的理想语言。这些低级操作不太可能发生变化,并且C相比Go还提高了性能。所以,如果你是一个有性能与低级操作需求的 Gopher ,就有充分的理由来学习C语言。

C 的优势体现在最接近底层机器的地方,而Go的优势在离用户较近的地方能得到最大发挥。当然,这并不是说两者都不能在对方的空间里工作,但这样做会增加“摩擦”。当你的需求从追求灵活性转变为注重效率时,用C重写库或服务的理由就更充分了。

总之,虽然Go和C的设计有很大的不同,但它们也有很多相似性,具备发挥兼容优势的基础。并且,当我们同时使用这二者时,就可以既有很大的灵活性,又有很好的性能,可以说是相得益彰!

五. 写在最后

今天的加餐中,我主要是基于C与Go的比较来讲解的,对于Go语言的特性并没有作详细展开。如果你还想进一步了解Go语言的设计哲学、语法特性、程序设计相关知识,欢迎来学习我在极客时间上的专栏《Tony Bai ·Go语言第一课》。在这门课里,我会用我十年Gopher的经验,带给你一条系统、完整的Go语言入门路径。

感谢你看到这里,如果今天的内容让你有所收获,欢迎把它分享给你的朋友。


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2022年,Gopher部落全面改版,将持续分享Go语言与Go应用领域的知识、技巧与实践,并增加诸多互动形式。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

我爱发短信:企业级短信平台定制开发专家 https://tonybai.com/。smspush : 可部署在企业内部的定制化短信平台,三网覆盖,不惧大并发接入,可定制扩展; 短信内容你来定,不再受约束, 接口丰富,支持长短信,签名可选。2020年4月8日,中国三大电信运营商联合发布《5G消息白皮书》,51短信平台也会全新升级到“51商用消息平台”,全面支持5G RCS消息。

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博:https://weibo.com/bigwhite20xx
  • 微信公众号:iamtonybai
  • 博客:tonybai.com
  • github: https://github.com/bigwhite
  • “Gopher部落”知识星球:https://public.zsxq.com/groups/51284458844544

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats