目录：
1、go-build
2、go-embed
3、go-generate
1、go-build：
构建约束也称之为条件编译，就是可以对某些源代码文件指定在特定的平台，架构，编译器甚至Go版本下面进行编译，在其他环境中会自动忽略这些文件。go支持两种方式的构建约束，一种是文件后缀名的方式一种是在文件的头部通过注释的方式。
文件后缀名构建约束的格式为：格式就是文件名_系统名_架构名.go
例如：
user_windows_amd64.go //在 windows 中 amd64 架构下才会编译，其他的环境中会自动忽略
user_linux_arm.go // 在 linux 中的 arm 架构下才会编译，其他环境中会自动忽略
注释的构建约束则如下规则：
1)、1.16之前老版本构建约束：
go 1.16之前的构建约束格式为构建约束的语法是// +build这种形式，如果多个条件组合，通过空格、逗号或多行构建约束表示，逗号表示 AND，空格表示OR，!表示NOT，换行表示AND。
// +build linux,386 darwin,!cgo
它表示的意思是：(linux AND 386) OR (darwin AND (NOT cgo)) ，有些时候，多个约束分成多行书写，会更易读些：
// +build linux darwin
// +build amd64
这相当于：(linux OR darwin) AND amd64
2)、1.17新版本构建约束：
新版的构建约束，注意"//"和"go"之间不能有空格：
//go:build
同时新版语法使用布尔表达式，而不是逗号、空格等。布尔表达式，会更清晰易懂，出错可能性大大降低。
采用新语法后，一个文件只能有一行构建语句，而不是像旧版那样有多行。这样可以避免多行的关系到底是什么的问题。
Go1.17 中，gofmt 工具会自动根据旧版语法生成对应的新版语法，为了兼容性，两者都会保留。比如原来是这样的：
// +build !windows,!plan9
执行 Go1.17 的 gofmt 后，变成了这样：
//go:build !windows && !plan9
// +build !windows,!plan9
如果文件中已经有了这两种约束形式，gofmt 会根据 //go:buid 自动覆盖 // +build 的形式，确保两者表示的意思一致。如果只有新版语法，不会自动生成旧版的，这时，你需要注意，它不兼容旧版本了。
2、go-embed：
//go:embed指令是Go 1.16版本新增的官方编译指令，它可以将任何文件或者文件夹的内容打包到编译出的可执行文件中。
简单来说，我们可以给代码添加一行特殊的注释来，Go 编译器知道是要嵌入文件还是嵌入文件夹。注释长得像"//go:embed 文件名"。注释占一行，紧接着是一个变量。如果要嵌入文件，变量的类型得是 string 或者 []byte，如果要嵌入一组文件，变量的类型得是embed.FS。指令格式有三种形式：
- //go:embed path…：path… 是需要嵌入的文件或目录，可以为多个，用空格分隔；
- //go:embed regexp：regexp 是需要嵌入的文件名或目录名的正则表达式；
- //go:embed dir/.ext：dir/.ext 是需要嵌入的某个目录下特定扩展名的文件；
注意事项：
- //go:embed是Go语言中的指令，看起来很像注释但是并非是注释，其中//和go:embed两者之间不能有空格，必须挨在一起；
- //go:embed后面接要嵌入的文件路径，以相对路径形式声明文件路径，文件路径和//go:embed指令之间相隔一个空格，这里文件相对路径；相对的是当前源代码文件的路径，并且这个路径不能以/或者./开头；
- 必须要导入embed包才能够使用//go:embed指令；
- 如果嵌入的文件夹中包含有以.或者_开头的文件，这些文件就会被视为隐藏文件，会被排除，不会被嵌入；
- 我们还可以使用通配符形式嵌入文件夹，例如：//go:embed resource/*，使用通配符形式时，隐藏文件也会被嵌入，并且文件夹本身也会被嵌入；
1)、嵌入单个文件：
例如：假设我们有一个文件叫 data.txt，然后我们希望在程序中引用它，通过 //go:embed 指令即可嵌入。
data.txt文件内容如下：
hello go embed!
将data.txt文件嵌入到程序中赋值到data变量中
package main
import (
"embed"
"fmt"
)
//go:embed data.txt
var data string
func main() {
fmt.Println("embed data info:", data)
}
在这个示例中，我们使用//go:embed data.txt将 data.txt 文件嵌入到了可执行文件中，在go build时编译器会把data.txt内容直接附给变量data，然后在 main() 函数中输出了 data 变量的值。
2)、嵌入多个文件：
package main
import (
"embed"
"fmt"
)
// 嵌入多个文件并作为embed.FS类型
// 将当前目录下test.txt和demo.txt嵌入至可执行文件，并存放到embed.FS对象中
//go:embed test.txt demo.txt
var embedFiles embed.FS
func main() {
// 读取嵌入的文件，返回字节切片
testContent, _ := embedFiles.ReadFile("test.txt")
demoContent, _ := embedFiles.ReadFile("demo.txt")
// 将读取到的字节切片转换成字符串输出
fmt.Println(string(testContent))
fmt.Println(string(demoContent))
}
指令部分并不需要改，将接收变量类型改成embed.FS即可，这样可以同时嵌入多个文件，在//go:embed指令后接多个要嵌入的文件路径即可，多个文件路径之间使用空格隔开。最后通过embed.FS对象的ReadFile方法，即可读取指定的嵌入的文件的内容，参数为嵌入的文件名，返回读取到的文件内容（byte切片形式）和错误对象。
所以，我们完全就可以把embed.FS对象想象成一个文件夹，只不过它是个特殊的文件夹，它位于编译后的可执行文件内部。那么使用ReadFile函数读取文件时，也是指定读取这个内部的文件夹中的文件，上述我们使用//go:embed指令嵌入了两个文件，就可以视为这两个文件在编译时被放入到这个特殊的“文件夹”中去了，只不过文件放进去后文件名是不会改变的。
3、go-generate：
Go 语言注释的另一个有趣的用法是通过 go generate 命令工具生成代码。 go generate 是 Go 语言标准工具包的一部分，它通过运行用户指定的外部命令以编程方式生成源 (或其他) 文件。go generate 的工作方式是扫描 .go 程序，寻找其中包含要运行的命令的特殊注释，然后执行它们。
具体来说，go generate 查找以 go:generate 开头的注释（注释标记和文本开始之间没有空格），如下：
//go:generate <command> <arguments>
3.1、generate命令工具使用：
//打印当前目录下所有文件，将被执行的命令
$go generate -n ./...
// 对包下所有Go文件进行处理
$go generate github.com/ysqi/repo
// 打印包下所有文件，将被执行的命令
$go generate -n runtime
3.2、go-generate注释使用：
需在的代码中配置generate标记，则在执行go generate时可被检测到。go generate执行时，实际在扫描如下内容：
//go:generate command argument...
generate命令不是解析文件，而是逐行匹配以//go:generate 开头的行(前面不要有空格)。故命令可以写在任何位置，也可存在多个命令行。
//go:generate后跟随具体的命令。命令为可执行程序，形同在Shell下执行。所以命令是在环境变量中存在，也可是完整路径。如：
package main
import "fmt"
//go:generate echo hello
//go:generate go run main.go
//go:generate echo file=$GOFILE pkg=$GOPACKAGE
func main() {
fmt.Println("main func")
}
// 执行后输出如下结果：
$ go generate
hello
man func
file=main.go pkg=main
在执行go generate时将会加入些信息到环境变量，可在命令程序中使用,相关变量如下：
- $GOARCH：架构 (arm, amd64, etc.)；
- $GOOS：linux, windows等等；
- $GOFILE：当前处理中的文件名；
- $GOLINE：当前命令在文件中的行号；
- $GOPACKAGE：当前处理文件的包名；
- $DOLLAR：固定的"$",不清楚用途；
3.2.1、使用示例：
比如我们定义一个对象后，为了打印友好内容，我们经常手工定义对应枚举常量的String方法或映射，用于输出对应枚举常量的友好信息。当增加一个枚举常量的时候我们都需增加对应的字符映射。
type Status int
const (
Offline Status = iota
Online
Disable
Deleted
)
var statusText = []string{"Offline", "Online", "Desable", "Deleted"}
func (s Status) String() string {
v := int(s)
if v < 0 || v > len(statusText) {
return fmt.Sprintf("Status(%d)", s)
}
return statusText[v]
}
这里我们可以使用generate来生成对枚举常量的友好输出信息。
1)、编写使用go generate工具根据注释生成代码的go程序：
package main
import (
"bytes"
"flag"
"fmt"
"go/ast"
"go/build"
"go/format"
"go/parser"
"go/token"
"io/ioutil"
"log"
"os"
"path/filepath"
"strings"
"text/template"
)
var (
pkgInfo *build.Package
)
var (
typeNames = flag.String("type", "", "必填，逗号连接的多个Type名")
)
func main() {
flag.Parse()
if len(*typeNames) == 0 {
log.Fatal("-type 必填")
}
consts := getConsts()
src := genString(consts)
//保存到文件
outputName := "./status2str_gen.go"
if outputName == "" {
types := strings.Split(*typeNames, ",")
baseName := fmt.Sprintf("%s_string.go", types[0])
outputName = filepath.Join(".", strings.ToLower(baseName))
}
err := ioutil.WriteFile(outputName, src, 0644)
if err != nil {
log.Fatalf("writing output: %s", err)
}
}
func getConsts() map[string][]string {
//获得待处理的Type
types := strings.Split(*typeNames, ",")
typesMap := make(map[string][]string, len(types))
for _, v := range types {
typesMap[strings.TrimSpace(v)] = []string{}
}
//解析当前目录下包信息,即获取当前目录下所有go文件信息用于语法树解析
var err error
pkgInfo, err = build.ImportDir(".", 0)
if err != nil {
log.Fatal(err)
}
fset := token.NewFileSet()
for _, file := range pkgInfo.GoFiles {
//解析go文件内容
f, err := parser.ParseFile(fset, file, nil, 0)
if err != nil {
log.Fatal(err)
}
typ := ""
//遍历每个树节点
ast.Inspect(f, func(n ast.Node) bool {
decl, ok := n.(*ast.GenDecl)
// 只需要const
if !ok || decl.Tok != token.CONST {
return true
}
for _, spec := range decl.Specs {
vspec := spec.(*ast.ValueSpec)
if vspec.Type == nil && len(vspec.Values) > 0 {
// 排除 v = 1 这种结构
typ = ""
continue
}
//如果Type不为空，则确认typ
if vspec.Type != nil {
ident, ok := vspec.Type.(*ast.Ident)
if !ok {
continue
}
typ = ident.Name
}
//typ是否是需处理的类型
consts, ok := typesMap[typ]
if !ok {
continue
}
//将所有const变量名保存
for _, n := range vspec.Names {
consts = append(consts, n.Name)
}
typesMap[typ] = consts
}
return true
})
}
return typesMap
}
func genString(types map[string][]string) []byte {
const strTmp = `
package {{.pkg}}
import "fmt"
{{range $typ,$consts :=.types}}
func (c {{$typ}}) String() string{
switch c { {{range $consts}}
case {{.}}:return "{{.}}"{{end}}
}
return fmt.Sprintf("Status(%d)", c)
}
{{end}}
`
pkgName := os.Getenv("GOPACKAGE")
if pkgName == "" {
pkgName = pkgInfo.Name
}
data := map[string]interface{}{
"pkg": pkgName,
"types": types,
}
//利用模板库，生成代码文件
t, err := template.New("").Parse(strTmp)
if err != nil {
log.Fatal(err)
}
buff := bytes.NewBufferString("")
err = t.Execute(buff, data)
if err != nil {
log.Fatal(err)
}
//格式化
src, err := format.Source(buff.Bytes())
if err != nil {
log.Fatal(err)
}
return src
}
// 将上面的程序编译为myenumstr
$go build -o myenumstr
2)、为要生成对应友好输出的对象添加generate注释：
package main
type Status int
//go:generate ./myenumstr -type Status,Color
const (
Offline Status = iota
Online
Disable
Deleted
)
type Color int
const (
Write Color = iota
Red
Blue
)
// 执行go工具的generate的命令
$go generate
