构建二进制可执行文件

环境变量

你可以使用 os 包访问环境变量。

package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {

	os.Setenv("FOO", "1")
	fmt.Println("FOO:", os.Getenv("FOO"))
	fmt.Println("BAR:", os.Getenv("BAR"))

	fmt.Println()
	for _, e := range os.Environ() {
		pair := strings.SplitN(e, "=", 2)
		fmt.Println(pair[0], pair[1])
	}
}

Embed 指令

//go:embed 是一个编译器指令，允许程序在构建时将任意文件和文件夹包含在二进制文件中。

将 //go:embed 指令放在变量声明之前，并将 embed 包的 FS 函数的结果赋值给该变量。

package main

import (
    "embed"
    "fmt"
)

//go:embed static/*.txt
var content embed.FS

func main() {
    // 使用嵌入的文件
    data, err := content.ReadFile("static/example.txt")
    if err != nil {
        fmt.Println("Error reading file:", err)
        return
    }
    fmt.Println("Content:", string(data))
}

命令行参数

os.Args 提供对原始命令行参数的访问。

package main

import (
	"fmt"
	"os"
)

func main() {
	// os.Args 的第一个元素是程序自身的名称
	fmt.Println("Program Name:", os.Args[0])

	fmt.Println("Command Line Arguments:", os.Args[1:])

	if len(os.Args) > 1 {
		fmt.Println("First Argument:", os.Args[1])
	}

	fmt.Println("All Arguments:")
	for i, arg := range os.Args {
		fmt.Printf("%d: %s\n", i, arg)
	}
}

尝试本地运行以查看参数。

go run main.go arg1 arg2 arg3

命令行标志

你可以使用 flag 包处理命令行标志。

package main

import (
	"flag"
	"fmt"
)

func main() {
	var name string
	var age int
	var married bool

	// StringVar、IntVar 和 BoolVar 定义标志并将值存储在提供的变量中
	flag.StringVar(&name, "name", "Lite Rank", "The name of the person")
	flag.IntVar(&age, "age", 20, "The age of the person")
	flag.BoolVar(&married, "married", false, "Is the person married")

	// 解析命令行参数和标志
	flag.Parse()

	fmt.Println("Name:", name)
	fmt.Println("Age:", age)
	fmt.Println("Married:", married)
}

你可以运行程序并为标志提供值，例如：

go run main.go -name="Alice" -age=25 -married=true

命令行子命令

您可以使用 flag 包以及其他包如 os 和 fmt 来在命令行应用程序中创建子命令。 一个常见的方法是使用 os.Args 切片来检查命令行参数，并判定当前正在执行哪个子命令。

package main

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

func main() {
	// 为主命令定义标志
	var verbose bool
	flag.BoolVar(&verbose, "verbose", false, "Enable verbose mode")

	// 解析主命令标志
	flag.Parse()

	// 检查是否有任何参数（子命令）
	if len(os.Args) < 2 {
		fmt.Println("Usage: main [options] <subcommand> [subcommand-options]")
		os.Exit(1)
	}

	// 根据子命令进行切换
	switch os.Args[1] {
	case "subcommand1":
		// 处理子命令1
		fmt.Println("Executing subcommand1")
		fmt.Println("Verbose mode:", verbose)
	case "subcommand2":
		// 处理子命令2
		fmt.Println("Executing subcommand2")
		fmt.Println("Verbose mode:", verbose)
	default:
		fmt.Println("Unknown subcommand:", os.Args[1])
		os.Exit(1)
	}
}

你可以以如下方式运行程序，使用子命令和附加选项：

go run main.go -verbose subcommand1

Go 构建

在 Go 中，go build 命令用于编译 Go 源代码文件。当你无参数运行 go build 时，它会编译当前目录中的 Go 程序，并创建一个与当前目录路径的最后一个元素同名的可执行文件。

指定输出文件

你可以使用 -o 标志指定输出文件的名称：

go build -o output_binary_filename

为不同平台构建

你可以使用 GOOS 和 GOARCH 环境变量来构建不同操作系统或不同体系结构的产物：

GOOS=linux GOARCH=amd64 go build

持续前进！持续学习！