Use of go package

go Use of the bag

brief introduction

In Engineering Go Language development projects ,Go The source reuse of language is based on the package （package） Based on . package There are many Go Source code collection , It's an advanced code reuse scheme ,Go Language provides us with many built-in packages , Such as fmt、os、io etc. .

Definition package

Packages make it easy for us to organize code , Write the same type code under a package , Easy to manage . A package can be simply understood as a storage .go File folder , All under this folder go file , You need to add the following code in the first line of the code , Declare that the file belongs to that package .

package  Package name 

matters needing attention ：

• There can only be one package under a folder , Files of the same package cannot be in multiple folders .
• The package name can not be the same as the folder name , Package name cannot contain - Symbol .
• Package name is main The package of is the entry package of the application , Compile without main Package source code will not get executable .

visibility

If you want to refer to an identifier in another package in one package （ Such as variable 、 Constant 、 type 、 Functions, etc ） when , The identifier must be visible （public）. stay Go In a language, you only need to capitalize the initial of an identifier to make it visible to the outside world .

package test

import "fmt"

var a = 100 //  Initial lowercase , The external package is not visible , Can only be used in a package 
const Mode = 200 //  title case , Can be used in other packages 

func main()  {
    

}

func Test(){
    
	fmt.Println(" Can be used in external packages ")
}

func test()  {
    
	var Age int = 18
	fmt.Println(Age)  //  Function local variable , The external package is not visible , Can only be used in the current function class 
	fmt.Println(" Can only be used in a package ")
}

Field names in structs and method names in interfaces are capitalized , External packages can access these fields and methods . for example ：

type Student struct {
    
	Name  string // Methods that can be accessed outside the package 
	class string // Only fields accessed within the package 
}

type Payer interface {
    
	init() // Only methods accessed within the package 
	Pay()  // Methods that can be accessed outside the package 
}

Package import

Reference the contents of other packages in the code , Need to use import The package used for keyword import . The specific syntax is as follows :

import " The path of the package "
import "day02/package1"  //  Single line import 
import (      //  Multiline import 
	"day02/test"
	"fmt"
)

matters needing attention ：

• import The import statement is usually placed below the package declaration statement at the beginning of the file .
• The imported package name needs to be wrapped in double quotes .
• Recommended go model Management package ,go path It's from $GOPATH/src/ And then we start to calculate , Use / Path separation .
• Go It is forbidden to import the package circularly in the language .
• The package name and the folder where the package is located can be different , But it is recommended not to modify , use The package name is just the file name
• Use the identifier in the import package , Should take Package name . identifier Way to use

//  Create a folder for test,test Create s2 file 
	// package test //  The default package name is the same as the folder name  test
    package t1

    const Mode = 200 //  title case , Can be used in other packages 

//  stay main The following is used in the package 
	package main

    import (
        "day02/test"  //  The path of the package 
        "fmt"
    )

    func main()  {
    
        fmt.Println(t1.Mode)   //  Package name . identifier 
    }

main Functions and main package

All executable Go The program must contain a main function . This function is the entry to the program .main Functions should be placed in main In bag .

In a project , Only one is allowed main function , There is only one entry , Usually run a single go file , File required (file) Form operation .

package main

func main()  {
    
	
}

init function

stay Go When a language program executes, the import package statement will automatically trigger the inside of the package init() Function call . It should be noted that ： init() The function has no arguments and no return value . init() Function is automatically called to execute when the program is running , You can't call it in your code .

func init(){    //  Sense and python in __init__ Almost the same effect 
}

init Functions can be used to perform initialization tasks , It can also be used to verify the correctness of the program before starting execution .

The initialization sequence of packages is as follows ：

1. First initialize the package level （Package Level） The variable of
2. Next call init function . Bags can have multiple init function （ In one file or distributed in multiple files ）, They are called in the order that the compiler parses them .

If one package imports another , The imported package will be initialized first .

Although a package may be imported multiple times , But it will only be initialized once .

Go The compiler then builds a tree of package references , Then determine the compilation order according to the reference order , Compile the code of these packages in turn .

At run time , The last imported package will be initialized and called first init() function , As shown in the figure below ：

go path turn go moduls

go stay 1.11 Support later go moduls Pattern , It is also the recommended package management mode

If you use go path Model for development , All project codes must be placed in go path The next path src Under the document , Otherwise, we can't find , Including built-in package , The third package , Therefore, it is extremely inconvenient .

however , Inevitably, some old projects used go path Management package , therefore go path turn go moduls It is necessary to .

Use go moduls, The code does not need to be placed in src Under the folder , Any path can , But there must be one under the project go.mod Folder , The production order is as follows :

go mod init  Project name    // go path  turn  go mod  Execution can be   Generate 
//  If there is a third-party package , It needs to be done again 
go mod tidy  //  I will download the third-party package