Loading...
墨滴

盘胧

2021/08/12  阅读:28  主题:山吹

golang-命令源码文件

命令源码文件

命令源码文件的用途是什么,怎样编写它?

命令源码文件是程序的运行入口,是每个可独立运行的程序必须拥有的。我们可以通过构建或安装,生成与其对应的可执行文件,后者一般会与该命令源码文件的直接父目录同名

如果一个源码文件声明属于main包,并且包含一个无参数声明且无结果声明的main函数,那么它就是命令源码文件。

package main

import "fmt"

func main() {
  fmt.Println("Hello, world!")
}

如果你把这段代码存成 demo1.go 文件,那么运行go run demo1.go命令后就会在屏幕(标准输出)中看到Hello, world!

deMacBook-Pro demo % go run src/main.go 
Hello, world!

当需要模块化编程时,我们往往会将代码拆分到多个文件,甚至拆分到不同的代码包中。但无论怎样,对于一个独立的程序来说,命令源码文件永远只会也只能有一个。如果有与命令源码文件同包的源码文件,那么它们也应该声明属于main包。

无论是 Linux 还是 Windows,如果你用过命令行(command line)的话,肯定就会知道几乎所有命令(command)都是可以接收参数(argument)的。通过构建或安装命令源码文件,生成的可执行文件就可以被视为“命令”,既然是命令,那么就应该具备接收参数的能力。

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

在python里,我们可以通过。--xxx 的方式运行问文件,以及添加参数,其实参数就在os.args里存放,那么在go里其实也一样。 我们详细分析下 我们先看一段不完整的代码:

package main

import (
  // 需在此处添加代码。[1]
  "fmt"
)

var name string

func init() {
  // 需在此处添加代码。[2]
}

func main() {
  // 需在此处添加代码。[3]
  fmt.Printf("Hello, %s!\n", name)
}

直接运行 go run src/main.go

GOROOT=/usr/local/go #gosetup
GOPATH=/Users/xxx/go #gosetup
/usr/local/go/bin/go build -o /private/var/folders/8z/hnf40d2j5fld8n5tg_0kszzc0000gn/T/___go_build_main_go /Users/xxx/Documents/xxx/goproj/demo/src/main.go #gosetup
/private/var/folders/8z/hnf40d2j5fld8n5tg_0kszzc0000gn/T/___go_build_main_go
Hello, !

看上面输出有类似路径/private/var/folders/8z/hnf40d2j5fld8n5tg_0kszzc0000gn/T/___go_build_main_go的东西——这其实是go run命令构建上述命令源码文件时临时生成的可执行文件的完整路径。

那怎么添加参数?

Go 语言标准库中有一个代码包专门用于接收和解析命令参数。这个代码包的名字叫flag

flag package

导入flag,添加代码:

func init() {
 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.")

在main函数添加 flag.parse()

func main() {
 flag.Parse()
 fmt.Printf("Hello, %s!\n", name)
}

函数flag.Parse用于真正解析命令参数,并把它们的值赋给相应的变量。

对该函数的调用必须在所有命令参数存储载体的声明(这里是对变量name的声明)和设置(这里是对flag.StringVar函数的调用)之后,并且在读取任何命令参数值之前进行。

正因为如此,我们最好把flag.Parse()放在main函数的函数体的第一行。

此时,不添加参数直接运行go run src/main.go或者用你的goland直接run,刚才说了 第 3 个参数是为了指定在未追加该命令参数时的默认值,这里是everyone 看输出:

MacBook-Pro demo % go run src/main.go
Hello, everyone!

没错对吧~

传入参数

就直接上代码:

go run src/main.go -name 大帅比简称dsb

输出:

MacBook-Pro demo % go run src/main.go -name 大帅比简称dsb
Hello, 大帅比简称dsb!

注意是 -name。不是。--name

查看帮助 --help

直接使用help。众所周知

go run src/main.go --help             
Usage of /var/folders/8z/hnf40d2j5fld8n5tg_0kszzc0000gn/T/go-build3176059065/b001/exe/main:
  -name string
        The greeting object. (default "everyone")

告诉了你。参数是name。用 -name string,且默认值是 everyone

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

很多种方式,最简单的一种方式就是对变量flag.Usage重新赋值。flag.Usage的类型是func(),即一种无参数声明且无结果声明的函数类型。

flag.Usage变量在声明时就已经被赋值了,所以我们才能够在运行命令go run src/main.go --help时看到正确的结果。

注意,对flag.Usage的赋值必须在调用flag.Parse函数之前。

补充代码:

func main() {
 flag.Usage = func() { fmt.Fprintf(os.Stderr, "Usage of %s:\n""question")
 flag.PrintDefaults()
 }
 flag.Parse()
 fmt.Printf("Hello, %s!\n", name)
}

运行go run src/main.go --help输出:

MacBook-Pro demo % go run src/main.go --help
Usage of question:
  -name string
        The greeting object. (default "everyone")

现在再深入一层,我们在调用flag包中的一些函数(比如StringVar、Parse等等)的时候,实际上是在调用flag.CommandLine变量的对应方法。

flag.CommandLine相当于默认情况下的命令参数容器。所以,通过对flag.CommandLine重新赋值,我们可以更深层次地定制当前命令源码文件的参数使用说明。python也有类似的click包可提供命令行

现在我们把main函数体中的那条对flag.Usage变量的赋值语句注销掉,然后在init函数体的开始处添加如下代码:

func init() {
 flag.CommandLine = flag.NewFlagSet("", flag.ExitOnError)
 flag.CommandLine.Usage = func() {
  fmt.Fprintf(os.Stderr, "Usage of %s:\n""question")
  flag.PrintDefaults()
 }
 flag.StringVar(&name, "name""everyone""The greeting object.")
}

运行go run src/main.go --help输出:

MacBook-Pro demo % go run src/main.go --help             
Usage of question:
  -name string
        The greeting object. (default "everyone")

其输出会与上一次的输出的一致。不过后面这种定制的方法更加灵活

比如,当我们把为flag.CommandLine赋值的那条语句改为:

func init() {
 flag.CommandLine = flag.NewFlagSet("", flag.PanicOnError)
 flag.CommandLine.Usage = func() {
  fmt.Fprintf(os.Stderr, "Usage of %s:\n""question")
  flag.PrintDefaults()
 }
 flag.StringVar(&name, "name""everyone""The greeting object.")
}

运行go run src/main.go --help输出:

MacBook-Pro demo % go run src/main.go --help
Usage of question:
  -name string
        The greeting object. (default "everyone")
panic: flag: help requested

goroutine 1 [running]:
flag.(*FlagSet).Parse(0xc0000ba180, 0xc0000be010, 0x1, 0x1, 0xc0000b1f78, 0x1005b65)
        /usr/local/go/src/flag/flag.go:1007 +0x165
flag.Parse(...)
        /usr/local/go/src/flag/flag.go:1022
main.main()
        /Users/xxx/Documents/wush/goproj/demo/src/main.go:22 +0x85
exit status 2

这是由于我们在这里传给flag.NewFlagSet函数的第二个参数值是flag.PanicOnError。flag.PanicOnError和flag.ExitOnError都是预定义在flag包中的常量。

flag.ExitOnError的含义是,告诉命令参数容器,当命令后跟--help或者参数设置的不正确的时候,在打印命令参数使用说明后以状态码2结束当前程序。状态码2代表用户错误地使用了命令

flag.PanicOnError与之的区别是在最后抛出“运行时恐慌(panic)”。

上述两种情况都会在我们调用flag.Parse函数时被触发

有用的重点来了

创建私有的命令参数容器

下面再进一步,我们索性不用全局的flag.CommandLine变量,转而自己创建一个私有的命令参数容器。我们在函数外再添加一个变量声明:

var cmdLine = flag.NewFlagSet("question", flag.ExitOnError)

然后,我们把对flag.StringVar的调用替换为对cmdLine.StringVar调用,再把flag.Parse()替换为cmdLine.Parse(os.Args[1:])。 整体代码:

package main

import (
 "flag"
 "fmt"
 "os"
)

var name string

var cmdLine = flag.NewFlagSet("question", flag.ExitOnError)

func init() {
 cmdLine.StringVar(&name, "name""everyone""The greeting object.")
}

func main() {
 cmdLine.Parse(os.Args[1:])
 fmt.Printf("Hello, %s!\n", name)
}

运行go run src/main.go --help输出:

MacBook-Pro demo % go run src/main.go --help
Usage of question:
  -name string
        The greeting object. (default "everyone")

其中的os.Args[1:]指的就是我们给定的那些命令参数。这样做就完全脱离了flag.CommandLine*flag.FlagSet类型的变量cmdLine拥有很多有意思的方法

这样做的好处依然是更灵活地定制命令参数容器。但更重要的是,你的定制完全不会影响到那个全局变量flag.CommandLine

flag的更多用法参照这里:flag官方

或者直接使用godoc命令在本地启动一个 Go 语言文档服务器。怎样使用godoc命令?你可以参看Godoc

盘胧

2021/08/12  阅读:28  主题:山吹

作者介绍

盘胧