Go is a compiled, static type, concurrent type, and garbage collection function. In Go language, packages are collections of functions and data, used to organize code and implement modular development. Through packages, developers can place relevant functions and data in the same directory for management, improving the maintainability and reusability of code. This article will explain in detail the usage of Go language package management based on actual cases.
1. Basic concepts and definitions of packages
1. Package definition
A package is composed of one or more source files suffixed with .go. The first line of these source files contains a declaration of the package name. Source files under the same folder, if they start with the same package name, they are considered to belong to the same package.
2. Package classification
main package: If the package name is main, the package will be compiled into an executable file. There can only be one main package in a Go program.
Non-main package: Non-main packages can be regarded as dependency packages and can be referenced by other packages.
3. Introducing packages
Use the import keyword to introduce other packages. Import statements are usually placed at the beginning of the file and below the package declaration statement. The path to the package is wrapped in double quotes.
2. Use of custom packages
1. Create a custom package
First, we create a simple project structure that contains a file and a custom package mypackage.
myproject/
├──
└── mypackage/
└──
Define a function SayHello in mypackage/:
// mypackage/
package mypackage
import "fmt"
func SayHello() {
("Hello, World!")
}
Introduce and use this custom package in:
//
package main
import "myproject/mypackage"
func main() {
()
}
2. Define multiple files for custom packages
Add another file in the mypackage directory to extend the function:
// mypackage/
package mypackage
import "fmt"
func SayGoodbye() {
("Goodbye, World!")
}
Update to use the new function:
//
package main
import "myproject/mypackage"
func main() {
()
()
}
3. Create a package with internal private functions
Add a file in the mypackage directory to provide a public interface to hide implementation details:
// mypackage/
package mypackage
import "fmt"
// Private functionsfunc add(a, b int) int {
return a + b
}
// Public functionsfunc DisplaySum(a, b int) {
sum := add(a, b)
("The sum is: %d\n", sum)
}
Calling the public function in:
//
package main
import "myproject/mypackage"
func main() {
()
()
(3, 4)
}
III. The use of GOPATH and Go Modules
1. Use of GOPATH
Before Go 1.11, Go code must be placed under GOPATH. GOPATH is a workspace for Go language, used to store Go code, dependency packages and compiled files.
Setting GOPATH: Under Unix systems, you can set export GOPATH=~/go in the terminal.
Place the project under $GOPATH/src, for example ~/go/src/myproject.
2. Use of Go Modules
Go version 1.11 introduced Go Modules for management of dependencies and version control. Go Modules makes it possible for projects to be placed in GOPATH/src, and can be placed anywhere.
Initialization module: Execute go mod init myproject in the root directory of the project and a file will be generated.
When referencing a local package, just introduce relative paths into the code.
When calling across modules, use the require keyword to specify the exact version.
For example, specify the dependency in:
module myproject
go 1.16
require (
/mylib v1.2.3
)
3. Download and use third-party packages
Use the go get command to download third-party packages. For example, download /gin-gonic/gin:
go get /gin-gonic/gin
Set up a proxy to speed up downloads. For example, set GOPROXY:
export GOPROXY= go get /gin-gonic/gin
Specify the version to download. For example, download version 1.6.3 of /gin-gonic/gin:
go get /gin-gonic/[email protected]
4. Introduce and use third-party libraries
Introduce and use /gin-gonic/gin:
package main
import (
"/gin-gonic/gin"
)
func main() {
r := ()
("/ping", func(c *) {
(200, {"message": "pong"})
})
() // listen and serve on 0.0.0.0:8080
}
4. Best practices for package management of Go language
1. Reasonably organize the code structure
Put the code for related functions in the same package, and put the code for different functions in different packages. Through a reasonable package structure, the readability and maintainability of the code can be improved.
2. Use internal private functions to hide implementation details
In the custom package, use the function name starting with lowercase letters to define private functions, and use the function name starting with uppercase letters to define public functions. In this way, implementation details can be hidden and only necessary interfaces can be provided for external use.
3. Use Go Modules to manage dependencies
Go Modules is a dependency management tool provided by Go language, which can easily manage project dependencies and versions. Using Go Modules can avoid the cumbersomeness of manual management of dependencies and improve development efficiency.
4. Regularly clean up useless dependencies
Use the go mod tidy command to clean up useless dependencies. This command adds missing modules, removes unwanted modules, and updates and files.
5. Use vendor directory to control dependency version
Putting third-party dependency packages in the vendor directory allows you to control the dependency version separately. In this way, the consistency of dependencies can be guaranteed even in different environments.
5. Case: Build a simple web application
1. Project structure
mywebapp/
├──
├──
└── controllers/
└──
2. Create a file
Execute go mod init mywebapp in the project root directory to generate the file.
3. Write controllers/
// controllers/
package controllers
import (
"net/http"
)
func HelloHandler(w , r *) {
([]byte("Hello, World!"))
}
4. Write
//
package main
import (
"mywebapp/controllers"
"net/http"
)
func main() {
("/", )
(":8080", nil)
}
5. Run a web application
Execute go run in the project root directory, and then visit http://localhost:8080 in the browser to see the output of "Hello, World!".
6. Summary
The Go language package management mechanism is the key to implementing modular development and code reuse. With a reasonable package structure, developers can organize and manage the code in the project, making it clearer and easier to maintain.
In short, the Go package management mechanism provides developers with flexible and powerful tools to organize and manage code. By using packages and dependency management tools rationally, developers can build clear, maintainable and extensible Go projects.
This is the end of this article about how to manage packages in Go. For more related Go packages, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!