How to compile golang

The go build command used in Go language is mainly used to compile code. During the compilation process of the package, if necessary, the packages associated with it will be compiled at the same time.

go build has many compilation methods, such as no-parameter compilation, file list compilation, specified package compilation, etc. You can use these methods to output executable files.

go build No parameter compilation

The directory relationship of the code relative to GOPATH is as follows:

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

main.go code is as follows:

package main

import (
    "fmt"
)

func main() {

    // 同包的函数
    pkgFunc()

    fmt.Println("hello world")
}

lib.go code is as follows:

package main
import "fmt"
func pkgFunc() {
    fmt.Println("call pkgFunc")
}

If there are no package references that depend on GOPATH in the source code, then these source codes can use parameterless go build. The format is as follows:

go build

Use the go build command in the directory where the code is located (./src/chapter11/gobuild), as shown below:

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

Command line instructions And the output description is as follows:

Line 1, go to the source code directory of this example.

Line 2, go build will search the go source code of the current directory when compilation starts. In this example, go build will find two files, lib.go and main.go. After compiling these two files, an executable file with the current directory name is generated and placed in the current directory. The executable file here is go build.

Lines 3 and 4 list the files in the current directory. The compilation is successful and the go build executable file is output.

Line 5, run the executable file go build in the current directory.

Lines 6 and 7, the output content after executing go build.

go build file list

When compiling multiple source code files in the same directory, you can provide multiple file names after go build, and go build will compile these source codes. , output the executable file, the format of "go build file list" is as follows:

go build file1.go file2.go……

Use go build in the directory where the code is located (./src/chapter11/gobuild), and add the file to be compiled after go build Source file name, the code is as follows:

$ 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

Command line instructions The output description is as follows:

In line 1, add the file list after go build and select the Go source code that needs to be compiled.

Lines 2 and 3 list the files in the current directory after compilation. This time the executable file name becomes main.

Lines 4 to 6 execute the main file and get the expected output.

Line 7, try to adjust the order of the file list and put lib.go at the top of the list.

On lines 8 and 9, the lib executable file appears in the compilation result.

When compiling using the "go build file list" method, the executable file selects the first source code file in the file list as the executable file name for output by default.

go build package

After setting GOPATH, "go build package" can be compiled directly based on the package name, even if the files in the package are added (added) or deleted ( Except) does not affect compilation directives.

1) The directory relationship between the code location and source code

relative to GOPATH is as follows:

.
└── src
└── chapter11
└ ─ ├ ──Main.go
# ─ ─ mypkg
—— mypkg.go

## code is as follows:

package main
import (
    "chapter11/goinstall/mypkg"
    "fmt"
)
func main() {
    mypkg.CustomPkgFunc()
    fmt.Println("hello world")
}

mypkg.go code is as follows:

package mypkg
import "fmt"
func CustomPkgFunc() {
    fmt.Println("call CustomPkgFunc")
}

2) Compile command by package

Execute the following command to compile goinstall code by package:

$ export GOPATH=/home/davy/golangbook/code

$ go build -o main chapter11/goinstall

$ ./goinstall
call CustomPkgFunc
hello world

code The instructions are as follows:

Line 1, set the environment variable GOPATH. The path here is the author's directory. You can set GOPATH according to the actual directory.

Line 2, -o execution specifies the output file as main, followed by the name of the package to be compiled. Package names start relative to the src directory under GOPATH.

Lines 3 to 5, the compilation is successful, and the expected output is obtained after executing main.

For more golang knowledge, please pay attention to the golang tutorial column.

The above is the detailed content of How to compile golang. For more information, please follow other related articles on the PHP Chinese website!