极客时间已完结课程限时免费阅读

02 | 命令源码文件

02 | 命令源码文件-极客时间

02 | 命令源码文件

2018-08-13 郝林 来自北京
《Go语言核心36讲》
课程介绍

讲述：黄洲君

时长08:46大小8.02M

我们已经知道，环境变量 GOPATH 指向的是一个或多个工作区，每个工作区中都会有以代码包为基本组织形式的源码文件。
这里的源码文件又分为三种，即：命令源码文件、库源码文件和测试源码文件，它们都有着不同的用途和编写规则。（ 我在“预习篇”的基础知识图介绍过这三种文件的基本情况。）
（长按保存大图查看）
今天，我们就沿着命令源码文件的知识点，展开更深层级的学习。
一旦开始学习用编程语言编写程序，我们就一定希望在编码的过程中及时地得到反馈，只有这样才能清楚对错。实际上，我们的有效学习和进步，都是通过不断地接受反馈和执行修正实现的。
对于 Go 语言学习者来说，你在学习阶段中，也一定会经常编写可以直接运行的程序。这样的程序肯定会涉及命令源码文件的编写，而且，命令源码文件也可以很方便地用go run命令启动。
那么，我今天的问题就是：命令源码文件的用途是什么，怎样编写它？
这里，我给出你一个参考的回答：命令源码文件是程序的运行入口，是每个可独立运行的程序必须拥有的。我们可以通过构建或安装，生成与其对应的可执行文件，后者一般会与该命令源码文件的直接父目录同名。
如果一个源码文件声明属于main包，并且包含一个无参数声明且无结果声明的main函数，那么它就是命令源码文件。 就像下面这段代码：
package main
import "fmt"
func main() {
fmt.Println("Hello, world!")
}
如果你把这段代码存成 demo1.go 文件，那么运行go run demo1.go命令后就会在屏幕（标准输出）中看到Hello, world!
当需要模块化编程时，我们往往会将代码拆分到多个文件，甚至拆分到不同的代码包中。但无论怎样，对于一个独立的程序来说，命令源码文件永远只会也只能有一个。如果有与命令源码文件同包的源码文件，那么它们也应该声明属于main包。

问题解析

命令源码文件如此重要，以至于它毫无疑问地成为了我们学习 Go 语言的第一助手。不过，只会打印Hello, world是远远不够的，咱们千万不要成为“Hello, world”党。既然决定学习 Go 语言，你就应该从每一个知识点深入下去。
无论是 Linux 还是 Windows，如果你用过命令行（command line）的话，肯定就会知道几乎所有命令（command）都是可以接收参数（argument）的。通过构建或安装命令源码文件，生成的可执行文件就可以被视为“命令”，既然是命令，那么就应该具备接收参数的能力。
下面，我就带你深入了解一下与命令参数的接收和解析有关的一系列问题。

知识精讲

1. 命令源码文件怎样接收参数

我们先看一段不完整的代码：
package main
import (
// 需在此处添加代码。[1]
"fmt"
)
var name string
func init() {
// 需在此处添加代码。[2]
}
func main() {
// 需在此处添加代码。[3]
fmt.Printf("Hello, %s!\n", name)
}
如果邀请你帮助我，在注释处添加相应的代码，并让程序实现”根据运行程序时给定的参数问候某人”的功能，你会打算怎样做？
如果你知道做法，请现在就动手实现它。如果不知道也不要着急，咱们一起来搞定。
首先，Go 语言标准库中有一个代码包专门用于接收和解析命令参数。这个代码包的名字叫flag。
我之前说过，如果想要在代码中使用某个包中的程序实体，那么应该先导入这个包。因此，我们需要在[1]处添加代码"flag"。注意，这里应该在代码包导入路径的前后加上英文半角的引号。如此一来，上述代码导入了flag和fmt这两个包。
其次，人名肯定是由字符串代表的。所以我们要在[2]处添加调用flag包的StringVar函数的代码。就像这样：
flag.StringVar(&name, "name", "everyone", "The greeting object.")
函数flag.StringVar接受 4 个参数。
第 1 个参数是用于存储该命令参数值的地址，具体到这里就是在前面声明的变量name的地址了，由表达式&name表示。
第 2 个参数是为了指定该命令参数的名称，这里是name。
第 3 个参数是为了指定在未追加该命令参数时的默认值，这里是everyone。
至于第 4 个函数参数，即是该命令参数的简短说明了，这在打印命令说明时会用到。
顺便说一下，还有一个与flag.StringVar函数类似的函数，叫flag.String。这两个函数的区别是，后者会直接返回一个已经分配好的用于存储命令参数值的地址。如果使用它的话，我们就需要把
var name string
改为
var name = flag.String("name", "everyone", "The greeting object.")
所以，如果我们使用flag.String函数就需要改动原有的代码。这样并不符合上述问题的要求。
再说最后一个填空。我们需要在[3]处添加代码flag.Parse()。函数flag.Parse用于真正解析命令参数，并把它们的值赋给相应的变量。
对该函数的调用必须在所有命令参数存储载体的声明（这里是对变量name的声明）和设置（这里是在[2]处对flag.StringVar函数的调用）之后，并且在读取任何命令参数值之前进行。
正因为如此，我们最好把flag.Parse()放在main函数的函数体的第一行。

2. 怎样在运行命令源码文件的时候传入参数，又怎样查看参数的使用说明

如果我们把上述代码存成名为 demo2.go 的文件，那么运行如下命令就可以为参数name传值：
go run demo2.go -name="Robert"
运行后，打印到标准输出（stdout）的内容会是：
Hello, Robert!
另外，如果想查看该命令源码文件的参数说明，可以这样做：
$ go run demo2.go --help
其中的$表示我们是在命令提示符后运行go run命令的。运行后输出的内容会类似：
Usage of /var/folders/ts/7lg_tl_x2gd_k1lm5g_48c7w0000gn/T/go-build155438482/b001/exe/demo2:
-name string
The greeting object. (default "everyone")
exit status 2
你可能不明白下面这段输出代码的意思。
/var/folders/ts/7lg_tl_x2gd_k1lm5g_48c7w0000gn/T/go-build155438482/b001/exe/demo2
这其实是go run命令构建上述命令源码文件时临时生成的可执行文件的完整路径。
如果我们先构建这个命令源码文件再运行生成的可执行文件，像这样：
$ go build demo2.go
$ ./demo2 --help
那么输出就会是
Usage of ./demo2:
-name string
The greeting object. (default "everyone")

3. 怎样自定义命令源码文件的参数使用说明

这有很多种方式，最简单的一种方式就是对变量flag.Usage重新赋值。flag.Usage的类型是func()，即一种无参数声明且无结果声明的函数类型。
flag.Usage变量在声明时就已经被赋值了，所以我们才能够在运行命令go run demo2.go --help时看到正确的结果。
注意，对flag.Usage的赋值必须在调用flag.Parse函数之前。
现在，我们把 demo2.go 另存为 demo3.go，然后在main函数体的开始处加入如下代码。
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage of %s:\n", "question")
flag.PrintDefaults()
}
那么当运行
$ go run demo3.go --help
后，就会看到
Usage of question:
-name string
The greeting object. (default "everyone")
exit status 2
现在再深入一层，我们在调用flag包中的一些函数（比如StringVar、Parse等等）的时候，实际上是在调用flag.CommandLine变量的对应方法。
flag.CommandLine相当于默认情况下的命令参数容器。所以，通过对flag.CommandLine重新赋值，我们可以更深层次地定制当前命令源码文件的参数使用说明。
现在我们把main函数体中的那条对flag.Usage变量的赋值语句注销掉，然后在init函数体的开始处添加如下代码：
flag.CommandLine = flag.NewFlagSet("", flag.ExitOnError)
flag.CommandLine.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage of %s:\n", "question")
flag.PrintDefaults()
}
再运行命令go run demo3.go --help后，其输出会与上一次的输出的一致。不过后面这种定制的方法更加灵活。比如，当我们把为flag.CommandLine赋值的那条语句改为
flag.CommandLine = flag.NewFlagSet("", flag.PanicOnError)
后，再运行go run demo3.go --help命令就会产生另一种输出效果。这是由于我们在这里传给flag.NewFlagSet函数的第二个参数值是flag.PanicOnError。flag.PanicOnError和flag.ExitOnError都是预定义在flag包中的常量。
flag.ExitOnError的含义是，告诉命令参数容器，当命令后跟--help或者参数设置的不正确的时候，在打印命令参数使用说明后以状态码2结束当前程序。
状态码2代表用户错误地使用了命令，而flag.PanicOnError与之的区别是在最后抛出“运行时恐慌（panic）”。
上述两种情况都会在我们调用flag.Parse函数时被触发。顺便提一句，“运行时恐慌”是 Go 程序错误处理方面的概念。关于它的抛出和恢复方法，我在本专栏的后续部分中会讲到。
下面再进一步，我们索性不用全局的flag.CommandLine变量，转而自己创建一个私有的命令参数容器。我们在函数外再添加一个变量声明：
var cmdLine = flag.NewFlagSet("question", flag.ExitOnError)
然后，我们把对flag.StringVar的调用替换为对cmdLine.StringVar调用，再把flag.Parse()替换为cmdLine.Parse(os.Args[1:])。
其中的os.Args[1:]指的就是我们给定的那些命令参数。这样做就完全脱离了flag.CommandLine。*flag.FlagSet类型的变量cmdLine拥有很多有意思的方法。你可以去探索一下。我就不在这里一一讲述了。
这样做的好处依然是更灵活地定制命令参数容器。但更重要的是，你的定制完全不会影响到那个全局变量flag.CommandLine。
总结
恭喜你！你现在已经走出了 Go 语言编程的第一步。你可以用 Go 编写命令，并可以让它们像众多操作系统命令那样被使用，甚至可以把它们嵌入到各种脚本中。
虽然我为你讲解了命令源码文件的基本编写方法，并且也谈到了为了让它接受参数而需要做的各种准备工作，但这并不是全部。
别担心，我在后面会经常提到它的。另外，如果你想详细了解flag包的用法，可以到这个网址查看文档。或者直接使用godoc命令在本地启动一个 Go 语言文档服务器。怎样使用godoc命令？你可以参看这里。

思考题

我们已经见识过为命令源码文件传入字符串类型的参数值的方法，那还可以传入别的吗？这就是今天我留下的思考题。
默认情况下，我们可以让命令源码文件接受哪些类型的参数值？
我们可以把自定义的数据类型作为参数值的类型吗？如果可以，怎样做？
你可以通过查阅文档获得第一个问题的答案。记住，快速查看和理解文档是一项必备的技能。
至于第二个问题，你回答起来可能会有些困难，因为这涉及了另一个问题：“怎样声明自己的数据类型？”这个问题我在专栏的后续部分中也会讲到。如果是这样，我希望你记下它和这里说的另一问题，并在能解决后者之后再来回答前者。
戳此查看 Go 语言专栏文章配套详细代码。
分享给需要的人，Ta购买本课程，你将得18元
生成海报并分享

赞 53

提建议

© 版权归极客邦科技所有，未经许可不得传播售卖。 页面已增加防盗追踪，如有侵权极客邦将依法追究其法律责任。
上一篇
01 | 工作区和GOPATH
下一篇
03 | 库源码文件
unpreview
 写留言

精选留言(75)

  • 姜雨生
    置顶
    2019-02-28
    flag的讲解很棒，通过这个命令，我们就可以控制程序在不同环境的执行内容了，通过控制参数设置更多的内容！
    31
  • 咖啡色的羊驼
    2018-08-13
    看完本文，记住的两点: 1.源码文件分为三种:命令,库，测试。 2.编写命令源码文件的关键包: flag。 回答下问题: 1.命令源码文件支持的参数: int(int|int64|uint|uint64), float(float|float64) string, bool, duration(时间), var(自定义) 2.关键就是使用flag.var()，关键点在于需要实现flag包的Value接口。
    展开
    118
  • Dragoonium
    2018-08-13
    我试着把参数增加到两个，然后试试运行结果 func init() { flag.StringVar(&name, "name1", "ladies", "The greeting object 1") flag.StringVar(&name, "name2", "gentlemen", "The greeting object 2") } # go run test.go Hello gentlemen! 和想像的一样，name2的默认值覆盖了name1的默认值 # go run test.go -name1=Robert Hello Robert! 和想像的略有不同，只指定了name1，没有指定name2，输出了name1的指定值，name2的默认值没有生效 # go run test.go -name2=Jose Hello Jose! 没毛病 # go run test.go -name1=Robert -name2=Jose Hello Jose! 没毛病 # go run test.go -name2=Jose -name1=Robert Hello Robert! 这有点奇怪了，输出的值是以参数的先后顺序为准的，而不是以flag.StringVar函数的顺序为准的
    展开
    共 8 条评论
    76
  • Tron
    2018-09-05
    go语言ide还是推荐goland
    36
  • Abirdcfly
    2018-08-14
    解答一下Dragoonium同学的疑惑，在flag包的文档里第一个example里就有你提到的这种情况，注释已经说明白了。 我不太精确的翻译一下： 两个flag分享一个变量时可以用来做命令参数缩写，由于初始化顺序未定义，所以要确保两者使用同一默认值，并且他们必须在init()函数中设置
    展开
    共 1 条评论
    22
  • 何何何何何少侠
    2018-12-08
    1. 默认情况下，我们可以让命令源码文件接受哪些类型的参数值？ 答：前面讲过`flag`是专门用来处理命令行参数的包，所以我们只需要看`flag`这个包支持哪些数据结构就行了。结果如下： * int(int|int64|uint|uint64), * float(float|float64) * string, * bool, * time.duration(时间), * var(自定义，如FlagSet、Flag、实现Value接口等) 2. 我们可以把自定义的数据类型作为参数值的类型吗？如果可以，怎样做？ 答：显然是可以的，从上面的回答来看就知道可以。实现方式可以参考源码中`flag.CommandLine.Var(value Value,name string,usage string)`的实现，核心在于自定义的数据类型需要实现`Value`接口，只要实现了`Value`接口，这个问题也就解决了。 1. 目录结构 * rexlin600（我的`GOPATH`） * pkg * bin * src * flagfunc * custom_type.go * tflag.go * main * main.go 2. 编写`main.go`和`tflag.go`以及自定义的`custom_type.go` `main.go` ``` package main import ( "flagfunc" "fmt" ) // main method func main() { fmt.Println("==> hello,", flagfunc.CustomFlag) } ``` `tflag.go` ``` package flagfunc import ( "flag" "fmt" ) var CustomFlag customFlag // 测试自定义数据类型flag func TestCustomFlag() { fmt.Println("==> package flagfunc") // custom define Value flag.CommandLine.Var(&CustomFlag, "custom", "custom define test") // After all flags are defined, call flag.Parse() to parse the command line into the defined flags. flag.Parse() } ``` `custom_type.go` ``` package flagfunc import ( "strings" ) type customFlag string func newStringValue(val string, p *string) *customFlag { *p = val return (*customFlag)(p) } func (a *customFlag) Set(str string) error { str = strings.TrimSpace(str) *a = customFlag(str) return nil } func (a *customFlag) String() string { return "" } ``` 3. 测试：进入main.go所在路径，输入命令`go run main.go custom="{"\"rexlin600\"",18,"\"[email protected]\""}"`即可
    展开
    22
  • wjq310
    2018-08-15
    demo3之后，要import os
    14
  • lixiaofeng
    2019-12-18
    // 连接mysql的命令。很多监控脚本都是类似这样开头的。 package main import ( "fmt" "flag" "os" ) var hostname string var username string var pwd string var port string func init(){ flag.StringVar(&hostname, "hostname", "127.0.0.1", "server ip or hostname") flag.StringVar(&username, "username", "root", "the user name to login database") flag.StringVar(&pwd, "pwd", "", "the password of username") flag.StringVar(&port, "port", "3306", "the port of your mysql") } func main(){ //flag.Parse() flag.Usage = func(){ fmt.Fprintf(os.Stderr, "usage of %s\n", " Link to your MySQL!") } fmt.Printf("hostname: %s\nusernmae: %s\npassword: %s\nport: %s\n", hostname, username, pwd, port) } 执行结果： D:\Users\kyle.litj\go\src\mygocode\MYJK>go run main.go -hostname="192.168.10.10" -username="root" -pwd="root" -port="3306" hostname: 192.168.10.10 usernmae: root password: root port: 3306
    展开
    13
  • javaadu
    2018-08-13
    喜欢这种重实践和编码的风格，便于上手
    12
  • 云学
    2018-08-13
    init在main之前执行，go程序的执行顺序是否可以讲下
    11
  • alan
    2018-08-13
    感谢老师。感觉编码细节有些偏多了哈，希望多一些总结性和主观的内容。
    10
  • zhaopan
    2019-02-17
    1. 会出现冲突 2. 导入包的几种方式 2.1 常规方式 import “your/lib” 通过包名lib调用SayHello方法。lib.SayHello() 2.2 别名方式 import m “your/lib” 这里的 m 是包名 lib 的别名，m.SyayHello() 。该方式合适的场景： 1.包名过于复杂或者意思不明确。 2.包名和其他包冲突。 import mongo "mywebapp/libs/mongodb/db" import ydbgo "mywebapp/libs/yundb/db" 2.3 省略包名 import . “your/lib” 这里的点.符号表示，对包 lib 的调用直接省略包名. 2.4 初始化方式 improt _ “your/lib” 特殊符号“_” 仅仅会导致 lib 执行初始化工作，如初始化全局变量，调用 init 函数。
    展开
    6
  • 梦里追逐
    2018-08-15
    咱们用的都是哪个IDE？

    作者回复: 你好，我用的是goland，但是代码不会依赖于IDE的，只会依赖于Go语言本身。免费的编辑器推荐vs code。

    7
  • 成都福哥
    2018-08-15
    用自定义的cmdLine的时候，usage函数里的flag.PrintDefaults()应该相应的变成cmdLine.PrintDefaults()吧。
    6
  • 吉祥
    2018-08-13
    undefined: os 怎么回事

    作者回复: 你好，请到GitHub上下载完整的源码文件。

    共 2 条评论
    5
  • 弥撒
    2019-05-25
    老师好，在执行demo2.go程序运行的时候，我打印了一下init()方法和main()方法的执行顺序，发现init方法先与flag.Parse()这句话之前就运行了，这是什么原因，程序入口不是main方法吗？

    作者回复: 有这样一个规则： main 包中的所有 init 函数都会先于 main 函数执行，main 包直接依赖的那些代码包中的 init 函数会先于 main 包中的 init 函数执行，以此类推（与依赖方向完全相反）。

    4
  • mayunian
    2018-08-30
    老师，今天试了一下类型转换。 为什么转换var x uint = uint(-1) 的时候会报错？ 而var y int = -1 var x uint = uint(y)就不会报错呢？

    作者回复: -1是负数，编译器看出来了，帮你挑出来。y是int类型的变量，编译器不知道里面存的是不是负数，没法帮你挑出来。转换会成功结果会不正确。

    共 2 条评论
    4
  • 丸子说
    2018-08-14
    从flag.stringvar/flag.string到flag.commandline再到私有cmdline命令参数容器，循序渐进，由浅到深。
    4
  • 闪电瘸子
    2020-04-03
    值得称赞的是 作者将gopath， goroot， go的代码组织结构讲清楚了。 我看其他的文章好像详细讲这个的不多。。。
    3
  • 传说中的成大大
    2020-02-10
    不太明白的地方在于 flag.stringvar 和flag.parse的作用 前面调用了flag.stringvar并且已经传入了name地址 为什么还要再调用一次flag.parse？

    作者回复: 前者是“注册”，后者是“处理”。这是两个步骤。“处理”只会针对那些已“注册”的参数。打个比方，你报了个培训班，交了钱、拿到了入场证，这就相当于“注册”。但是你还得去上课，只有去了课堂才能学到东西，这就相当于“处理”。

    共 2 条评论
    3