So verwenden Sie den Build-Befehl in der Go-Sprache

In der Go-Sprache wird der Befehl „go build“ hauptsächlich zum Kompilieren von Code verwendet. Go-Sprachprogrammcode kann in eine ausführbare Binärdatei kompiliert werden, die Binärdatei muss jedoch manuell ausgeführt werden. „go build“ verfügt über viele Kompilierungsmethoden, z. B. Kompilierung ohne Parameter, Kompilierung von Dateilisten, Kompilierung spezifizierter Pakete usw. Sie können diese Methoden verwenden, um ausführbare Dateien auszugeben.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Die Go-Sprache ist eine kompilierte statische Sprache (wie die C-Sprache). Bevor ein Go-Sprachprogramm ausgeführt wird, muss es daher in eine binäre ausführbare Datei kompiliert werden.

Sie können Go-Sprachprogramme mit den von Go-Sprache bereitgestellten Befehlen go build oder go run kompilieren: go build或者go run命令对Go语言程序进行编译：

• go build命令可以将Go语言程序代码编译成二进制的可执行文件，但是需要我们手动运行该二进制文件；

• go run命令则更加方便，它会在编译后直接运行Go语言程序，编译过程中会产生一个临时文件，但不会生成可执行文件，这个特点很适合用来调试程序。

go build命令（go语言编译命令）

Go语言中使用 go build 命令主要用于编译代码。在包的编译过程中，若有必要，会同时编译与之相关联的包。

go build 有很多种编译方法，如无参数编译、文件列表编译、指定包编译等，使用这些方法都可以输出可执行文件。

go build 无参数编译

本小节需要用到的代码具体位置是./src/chapter11/gobuild。

代码相对于 GOPATH 的目录关系如下：

.
└── src
    └── chapter11
        └── gobuild
            ├── lib.go
            └── main.go

main.go 代码如下：

package main

import (
    "fmt"
)

func main() {
    // 同包的函数
    pkgFunc()
    fmt.Println("hello world")
}

lib.go 代码如下：

package main

import "fmt"

func pkgFunc() {
    fmt.Println("call pkgFunc")
}

如果源码中没有依赖 GOPATH 的包引用，那么这些源码可以使用无参数 go build。格式如下：

go build

在代码所在目录（./src/chapter11/gobuild）下使用 go build 命令，如下所示：

$ cd src/chapter11/gobuild/
$ go build
$ ls
gobuild  lib.go  main.go
$ ./gobuild
call pkgFunc
hello world

命令行指令和输出说明如下：

• 第 1 行，转到本例源码目录下。

• 第 2 行，go build 在编译开始时，会搜索当前目录的 go 源码。这个例子中，go build 会找到 lib.go 和 main.go 两个文件。编译这两个文件后，生成当前目录名的可执行文件并放置于当前目录下，这里的可执行文件是 go build。

• 第 3 行和第 4 行，列出当前目录的文件，编译成功，输出 go build 可执行文件。

• 第 5 行，运行当前目录的可执行文件 go build。

• 第 6 行和第 7 行，执行 go build 后的输出内容。

go build+文件列表

编译同目录的多个源码文件时，可以在 go build 的后面提供多个文件名，go build 会编译这些源码，输出可执行文件，“go build+文件列表”的格式如下：

go build file1.go file2.go……

在代码代码所在目录（./src/chapter11/gobuild）中使用 go build，在 go build 后添加要编译的源码文件名，代码如下：

$ go build main.go lib.go
$ ls
lib.go  main  main.go
$ ./main
call pkgFunc
hello world
$ go build lib.go main.go
$ ls
lib  lib.go  main  main.go

命令行指令和输出说明如下：

• 第 1 行在 go build 后添加文件列表，选中需要编译的 Go 源码。

• 第 2  行和第 3 行列出完成编译后的当前目录的文件。这次的可执行文件名变成了 main。

• 第 4～6 行，执行 main 文件，得到期望输出。

• 第 7 行，尝试调整文件列表的顺序，将 lib.go 放在列表的首位。

• 第 8 行和第 9 行，编译结果中出现了 lib 可执行文件。

提示：

使用“go build+文件列表”方式编译时，可执行文件默认选择文件列表中第一个源码文件作为可执行文件名输出。

如果需要指定输出可执行文件名，可以使用-o参数，参见下面的例子：

$ go build -o myexec main.go lib.go
$ ls
lib.go  main.go  myexec
$ ./myexec
call pkgFunc
hello world

上面代码中，在 go build 和文件列表之间插入了-o myexec参数，表示指定输出文件名为 myexec。

注意：

使用“go build+文件列表”编译方式编译时，文件列表中的每个文件必须是同一个包的 Go 源码。也就是说，不能像 C++ 一样将所有工程的 Go 源码使用文件列表方式进行编译。编译复杂工程时需要用“指定包编译”的方式。

“go build+文件列表

• go build Der Befehl kann Go-Sprachprogrammcode in eine binäre ausführbare Datei kompilieren, aber wir müssen die Binärdatei manuell ausführen

• Der Der Befehl go run ist praktischer. Er führt das Go-Sprachprogramm direkt nach dem Kompilierungsprozess aus, eine ausführbare Datei wird jedoch nicht generiert .

go build-Befehl (go-Sprachkompilierungsbefehl)

Der go build-Befehl wird hauptsächlich in der Go-Sprache verwendet Kompilieren Sie den Code. Während des Kompilierungsprozesses des Pakets werden bei Bedarf gleichzeitig die damit verbundenen Pakete kompiliert. 🎜🎜go build verfügt über viele Kompilierungsmethoden, z. B. Parameterlose Kompilierung, Dateilistenkompilierung, Kompilierung spezifizierter Pakete usw. Sie können diese Methoden verwenden, um ausführbare Dateien auszugeben. 🎜🎜🎜go build ohne Parameterkompilierung🎜🎜🎜Der spezifische Speicherort des in diesem Abschnitt benötigten Codes ist ./src/chapter11/gobuild. 🎜🎜Die Verzeichnisbeziehung des Codes relativ zu GOPATH ist wie folgt: 🎜

.
└── src
    └── chapter11
        └──goinstall
            ├── main.go
            └── mypkg
                └── mypkg.go

🎜main.go Der Code lautet wie folgt: 🎜

package main

import (
    "chapter11/goinstall/mypkg"
    "fmt"
)

func main() {
    mypkg.CustomPkgFunc()
    fmt.Println("hello world")
}

🎜lib.go Der Code lautet wie folgt: 🎜

package mypkg

import "fmt"

func CustomPkgFunc() {
    fmt.Println("call CustomPkgFunc")
}

🎜Wenn es keine abhängigen Paketverweise gibt auf GOPATH im Quellcode, dann können diese Quellcodes den Parameterlosen Go-Build verwenden. Das Format ist wie folgt: 🎜

$ export GOPATH=/home/davy/golangbook/code
$ go build -o main chapter11/goinstall
$ ./goinstall
call CustomPkgFunc
hello world

🎜Verwenden Sie den Befehl go build in dem Verzeichnis, in dem sich der Code befindet (./src/chapter11/gobuild), wie unten gezeigt: 🎜rrreee🎜Die Befehlszeilenanweisungen Die Ausgabeanweisungen lauten wie folgt: 🎜

• 🎜Zeile 1, gehe zum Quellcodeverzeichnis dieses Beispiels. 🎜
• 🎜Zeile 2: Wenn Go Build mit der Kompilierung beginnt, wird der Go-Quellcode im aktuellen Verzeichnis durchsucht. In diesem Beispiel findet go build zwei Dateien, lib.go und main.go. Nach dem Kompilieren dieser beiden Dateien wird eine ausführbare Datei mit dem aktuellen Verzeichnisnamen generiert und im aktuellen Verzeichnis abgelegt. Die ausführbare Datei wird hier erstellt. 🎜
• 🎜Zeilen 3 und 4 listen die Dateien im aktuellen Verzeichnis auf, die Kompilierung ist erfolgreich und die ausführbare Go-Build-Datei wird ausgegeben. 🎜
• 🎜Zeile 5: Führen Sie die ausführbare Datei go build im aktuellen Verzeichnis aus. 🎜
• 🎜Zeilen 6 und 7, der Ausgabeinhalt nach der Ausführung von go build. 🎜

🎜🎜go build+file list🎜🎜🎜Wenn Sie mehrere Quellcodedateien im selben Verzeichnis kompilieren, können Sie mehrere Dateinamen angeben, nachdem go build diese Quellcodes kompiliert und die ausführbare Datei ausgibt Datei, das Format von „go build + file list“ lautet wie folgt: 🎜rrreee🎜Verwenden Sie go build in dem Verzeichnis, in dem sich der Code befindet (./src/chapter11/gobuild), und fügen Sie den Namen der zu erstellenden Quellcodedatei hinzu Nach dem Kompilieren von Go Build lautet der Code wie folgt: 🎜 rrreee🎜Die Befehlszeilenanweisungen und Ausgabeanweisungen lauten wie folgt: 🎜

• 🎜Fügen Sie in Zeile 1 hinzu Öffnen Sie die Dateiliste nach dem Go-Build und wählen Sie den Go-Quellcode aus, der kompiliert werden muss. 🎜
• 🎜 Zeilen 2 und 3 listen die Dateien im aktuellen Verzeichnis nach der Kompilierung auf. Diesmal wird der Name der ausführbaren Datei zum Hauptdateinamen. 🎜
• 🎜Zeile 4–6, führen Sie die Hauptdatei aus und erhalten Sie die erwartete Ausgabe. 🎜
• 🎜Zeile 7, versuchen Sie, die Reihenfolge der Dateiliste anzupassen und lib.go an den Anfang der Liste zu setzen. 🎜
• 🎜In den Zeilen 8 und 9 erscheint die ausführbare lib-Datei im Kompilierungsergebnis. 🎜

🎜Tipps: 🎜🎜Beim Kompilieren mit der Methode „go build+file list“ wird als ausführbare Datei standardmäßig die erste Quellcodedatei in der Dateiliste verwendet Ausgabe des Namens der ausführbaren Datei. 🎜🎜Wenn Sie den Namen der ausführbaren Ausgabedatei angeben müssen, können Sie den Parameter -o verwenden, siehe Beispiel unten: 🎜rrreee🎜Im obigen Code wird - zwischen go build eingefügt und der Dateiliste. o myexec-Parameter, der angibt, dass der angegebene Ausgabedateiname myexec ist. 🎜🎜Hinweis: 🎜🎜Beim Kompilieren mit der Kompilierungsmethode „Go Build + Dateiliste“ muss jede Datei in der Dateiliste der Go-Quellcode desselben Pakets sein. Mit anderen Worten: Der Go-Quellcode aller Projekte kann nicht mit der Dateilistenmethode wie C++ kompiliert werden. Beim Kompilieren komplexer Projekte müssen Sie die Methode „Kompilierung spezifizierter Pakete“ verwenden. 🎜🎜Die Methode „go build+file list“ eignet sich besser für Tools, die in der Go-Sprache geschrieben sind und nur eine kleine Anzahl von Dateien haben. 🎜🎜🎜go build+package🎜🎜🎜Nach dem Festlegen von GOPATH kann „go build+package“ direkt basierend auf dem Paketnamen kompiliert werden. Auch wenn die Dateien im Paket hinzugefügt (hinzugefügt) oder gelöscht (gelöscht) werden Anweisungen werden nicht beeinträchtigt. 🎜🎜1) Code-Speicherort und Quellcode🎜

本小节需要用到的代码具体位置是./src/chapter11/goinstall。

本套教程所有源码下载地址：https://pan.baidu.com/s/1ORFVTOLEYYqDhRzeq0zIiQ    提取密码：hfyf

相对于GOPATH的目录关系如下：

.
└── src
    └── chapter11
        └──goinstall
            ├── main.go
            └── mypkg
                └── mypkg.go

main.go代码如下：

package main

import (
    "chapter11/goinstall/mypkg"
    "fmt"
)

func main() {
    mypkg.CustomPkgFunc()
    fmt.Println("hello world")
}

mypkg.go代码如下：

package mypkg

import "fmt"

func CustomPkgFunc() {
    fmt.Println("call CustomPkgFunc")
}

2) 按包编译命令

执行以下命令将按包方式编译 goinstall 代码：

$ export GOPATH=/home/davy/golangbook/code
$ go build -o main chapter11/goinstall
$ ./goinstall
call CustomPkgFunc
hello world

代码说明如下：

• 第 1 行，设置环境变量 GOPATH，这里的路径是笔者的目录，可以根据实际目录来设置 GOPATH。

• 第 2 行，-o执行指定输出文件为 main，后面接要编译的包名。包名是相对于 GOPATH 下的 src 目录开始的。

• 第 3～5 行，编译成功，执行 main 后获得期望的输出。

go build 编译时的附加参数

go build 还有一些附加参数，可以显示更多的编译信息和更多的操作，详见下表所示。

go build编译时的附加参数

附加参数	备  注
-v	编译时显示包名
-p n	开启并发编译，默认情况下该值为 CPU 逻辑核数
-a	强制重新构建
-n	打印编译时会用到的所有命令，但不真正执行
-x	打印编译时会用到的所有命令
-race	开启竞态检测

表中的附加参数按使用频率排列，读者可以根据需要选择使用。

【相关推荐：Go视频教程、编程教学】

Das obige ist der detaillierte Inhalt vonSo verwenden Sie den Build-Befehl in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!