What package must the go language have?

Go language must have a main package. Go language is a compiled static language, so before running a Go language program, it needs to be compiled into a binary executable file; to generate a Go language executable program, there must be a package named main, and in this package There must be and only one main function.

The operating environment of this tutorial: Windows 7 system, GO version 1.18, Dell G3 computer.

1. The concept of packages and source files

Go programs are composed by linking packages together. A package is composed of source files that define the constants, types, variables, and functions belonging to the package (they can be accessed by all files in the same package, and can also be used by other packages through export). The code of each package can be used as a small reuse unit and referenced by other projects.

Each source file has a package statement that defines which package it belongs to, followed by a possibly empty import collection that declares which packages need to be used, followed by possibly empty functions, types, and variables. , a collection of constants.

We can see that the belonging packages of files named code and errno are both errno. This shows that in Go, unlike Java, a class is not used as a reuse unit, but a package is used as a reuse unit. A very small multiplexing unit.

Summary: The smallest unit in Go is the package, and there can be multiple source files under the package. The source file is equivalent to the class class. Each source file declares the file through the package statement. Which package does it belong to.

2. main package

In the Go language, the package named main has a special meaning. The Go language compiler will try to compile a package with this name into a binary executable file. All executable programs compiled in Go must have a package named main.

To put it simply: To generate a Go language executable program, there must be a package named main, and there must be and only one main function under this package

When the compiler finds that the name of a package is main, it will also find that the function named main() is, otherwise the executable file will not be created. The main() function is the entry point of the program, so without this function, the program has no way to start executing. When the program is compiled, the directory name of the directory where the code that declares the main package is located will be used as the file name of the binary executable file.

3. Naming specifications for package directories

It is said that there is no rule without rules. Before developing the Go language, we must understand some of the characteristics and specifications of the Go language in order to better understand it. If you are good at developing high-quality, universal code, otherwise, developing a program that only you can understand is just for your own entertainment. This section gives an example of a naming convention based on some classic codes and company development habits. The example is as follows:

Based on this example diagram, I will explain the development specifications I understand:

• conf: This directory mainly stores configuration files

• handler: mainly stores the entry files of some programs, equivalent to the Collter layer in Java

• model: Mainly stored in files related to database operations

• pkg: Mainly saves some general tool class and other codes

• router: Mainly Save the code of the routing service

• service: mainly save the business code

• vendor: mainly save the dependency packages of the project itself

• conf.yaml: The project configuration file can be placed in the following directory or in the conf folder

• main.go: The entry point of the program, Generally placed in the root directory

4. Import

The introduction principle of the package

Program The initialization and execution start from the main package. If the main package also imports other packages, they will be imported in sequence during compilation. A package imported from multiple places will only be imported once. When a package is imported, if the package also imports other packages, the other packages will be imported first, and then the package-level constants and variables in these packages will be initialized, and then the init function (if any) will be executed. ),And so on. After all imported packages are loaded, the package-level constants and variables in the main package will be initialized, then the init function in the main package will be executed (if it exists), and finally the main function will be executed.
When a package is imported, dependencies are searched according to priority from high to low, roughly:

• The vendor directory under the current package.
• Search in the upper directory until you find the vendor directory under src.
• Look for dependent packages under GOPATH.
• Look in the GOROOT directory

Syntax for package import

The import command is often used when writing Go code. Import the package file. The method you see is as follows:

• General import

import(
    "fmt"
)

Then you can call it in the code in the following way

fmt.Println("hello world")

上面这个fmt是Go语言的标准库，他其实是去GOROOT下去加载该模块。

• 点操作

import (
   . "fmt"
)

这个点操作的含义就是这个包导入之后在你调用这个包的函数时，你可以省略前缀的包名，也就是前面你调用的fmt.Println(“hello world”)  可以省略的写成Println(“hello world”)。注意：该包内的函数不能与其重名。

• 别名操作

import( f “fmt” )

别名操作顾名思义可以把包命名成另一个用起来容易记忆的名字，别名操作调用包函数时前缀变成了重命名的前缀，即f.Println(“hello world”)，通常为了解决导入多个重名包的问题。

• _操作

import (
    _ "github.com/go-sql-driver/mysql"
)

_操作其实只是引入该包但不使用，通常只为了执行该包中所有的init()函数,最常见的就是上面的mysql包。

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

The above is the detailed content of What package must the go language have?. For more information, please follow other related articles on the PHP Chinese website!