Comment utiliser la commande build en langage go

Dans le langage Go, la commande "go build" est principalement utilisée pour compiler du code. Le code du programme du langage Go peut être compilé dans un fichier exécutable binaire, mais le fichier binaire doit être exécuté manuellement. "go build" a de nombreuses méthodes de compilation, telles que la compilation sans paramètre, la compilation de liste de fichiers, la compilation de packages spécifiés, etc. Vous pouvez utiliser ces méthodes pour générer des fichiers exécutables.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Le langage Go est un langage statique compilé (identique au langage C), donc avant d'exécuter un programme en langage Go, il doit être compilé dans un fichier exécutable binaire.

Vous pouvez compiler des programmes en langage Go via les commandes go build ou go run fournies par le langage Go : 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+文件列表

• La commande go build peut compiler le code du programme en langage Go dans un fichier exécutable binaire, mais nous devons exécuter manuellement le fichier binaire 

•  ; La commande go run est plus pratique. Elle exécutera le programme en langage Go directement après la compilation. Un fichier temporaire sera généré pendant le processus de compilation, mais un fichier exécutable ne sera pas généré. Cette fonctionnalité est très adaptée au débogage des programmes. .

commande go build (commande de compilation du langage go)

La commande go build est principalement utilisée dans le langage Go Compilez le code. Lors du processus de compilation du package, si nécessaire, les packages qui lui sont associés seront compilés en même temps. 🎜🎜go build dispose de nombreuses méthodes de compilation, telles que la compilation sans paramètres, la compilation de listes de fichiers, la compilation de packages spécifiés, etc. Vous pouvez utiliser ces méthodes pour générer des fichiers exécutables. 🎜🎜🎜go build sans compilation de paramètres🎜🎜🎜L'emplacement spécifique du code nécessaire dans cette section est ./src/chapter11/gobuild. 🎜🎜La relation de répertoire du code par rapport à GOPATH est la suivante : 🎜

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

🎜main.go Le code est le suivant : 🎜

package main

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

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

🎜lib.go Le code est le suivant : 🎜

package mypkg

import "fmt"

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

🎜S'il n'y a pas de références de packages qui dépendent sur GOPATH dans le code source, alors ces codes sources peuvent utiliser go build sans paramètre. Le format est le suivant : 🎜

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

🎜Utilisez la commande go build dans le répertoire où se trouve le code (./src/chapter11/gobuild), comme indiqué ci-dessous : 🎜rrreee🎜Les instructions en ligne de commande et les instructions de sortie sont les suivantes : 🎜

• 🎜Ligne 1, accédez au répertoire du code source de cet exemple. 🎜
• 🎜Ligne 2, lorsque go build démarre la compilation, il recherchera le code source go dans le répertoire courant. Dans cet exemple, go build trouvera deux fichiers, lib.go et main.go. Après avoir compilé ces deux fichiers, un fichier exécutable avec le nom du répertoire actuel est généré et placé dans le répertoire courant. Le fichier exécutable ici est go build. 🎜
• 🎜Les lignes 3 et 4 répertorient les fichiers dans le répertoire courant, la compilation est réussie et le fichier exécutable go build est généré. 🎜
• 🎜Ligne 5, exécutez le fichier exécutable go build dans le répertoire courant. 🎜
• 🎜Lignes 6 et 7, le contenu de sortie après l'exécution de go build. 🎜

🎜🎜go build+file list🎜🎜🎜Lors de la compilation de plusieurs fichiers de code source dans le même répertoire, vous pouvez fournir plusieurs noms de fichiers après que go build compilera ces codes sources et générera l'exécutable. Fichier, le format de "go build+file list" est le suivant : 🎜rrreee🎜Utilisez go build dans le répertoire où se trouve le code (./src/chapter11/gobuild), ajoutez le nom du fichier de code source à compilé après go build, le code est le suivant : 🎜 rrreee🎜Les instructions de ligne de commande et les instructions de sortie sont les suivantes : 🎜

• 🎜Dans la ligne 1, ajoutez la liste des fichiers après go build et sélectionnez le code source Go qui doit être compilé. 🎜
• 🎜 Les lignes 2 et 3 répertorient les fichiers du répertoire courant après compilation. Cette fois, le nom du fichier exécutable devient principal. 🎜
• 🎜Ligne 4~6, exécutez le fichier principal et obtenez le résultat attendu. 🎜
• 🎜Ligne 7, essayez d'ajuster l'ordre de la liste des fichiers et mettez lib.go en haut de la liste. 🎜
• 🎜Lignes 8 et 9, le fichier exécutable lib apparaît dans le résultat de la compilation. 🎜

🎜Conseils : 🎜🎜Lors de la compilation à l'aide de la méthode "go build+file list", le fichier exécutable est par défaut le premier fichier de code source de la liste de fichiers comme sortie du nom de fichier exécutable. 🎜🎜Si vous devez spécifier le nom du fichier exécutable de sortie, vous pouvez utiliser le paramètre -o, voir l'exemple ci-dessous : 🎜rrreee🎜Dans le code ci-dessus, - est inséré entre go build et la liste de fichiers. o le paramètre myexec, indiquant que le nom du fichier de sortie spécifié est myexec. 🎜🎜Remarque : 🎜🎜Lors de la compilation à l'aide de la méthode de compilation "go build+file list", chaque fichier de la liste de fichiers doit être le code source Go du même package. En d’autres termes, le code source Go de tous les projets ne peut pas être compilé à l’aide de la méthode de liste de fichiers comme C++. Lors de la compilation de projets complexes, vous devez utiliser la méthode "compilation de package spécifié". 🎜🎜La méthode "go build+file list" est plus adaptée aux outils écrits en langage Go avec seulement un petit nombre de fichiers. 🎜🎜🎜go build+package🎜🎜🎜Après avoir défini GOPATH, "go build+package" peut être compilé directement en fonction du nom du package Même si les fichiers du package sont ajoutés (ajoutés) ou supprimés (supprimés), la compilation. les instructions ne seront pas affectées. 🎜🎜1) Emplacement du code et code source🎜

本小节需要用到的代码具体位置是./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视频教程、编程教学】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!