Golang different package calls

Go language is an open source programming language. Its emergence has many advantages, including static type checking, garbage collection, and coroutines. When developing in the Go language, it is a common requirement to use functions and variables from different packages. This article will introduce some methods and techniques for calling different packages in the Go language.

1. Import the required packages

In the Go language, we need to use the import statement to import the required packages. For example, if we want to use the functions in the fmt package, then we can import the fmt package in the code:

import "fmt"

If we want to import multiple packages at the same time, You can use the following method:

import (
    "fmt"
    "time"
)

It should be noted that the imported package name must be unique. When using functions and variables in a package, you need to use the package name prefix to access them.

2. Package Visibility

In the Go language, the visibility of variables, functions, constants, etc. is controlled by the case of the first letter. If the first letter of the variable we define is capitalized, then the variable can be accessed by external packages, otherwise it cannot be accessed by external packages. For example, we define the following function:

func GetUserId() string {
    // TODO
}

Since the first letter of the function name GetUserId is capitalized, this function can be accessed by other packages.

When we import a package, only the functions and variables exposed in the package can be accessed. For example, suppose we have a package called mylib, which has a private variable count:

package mylib

var count int = 0

If we import mylib# in other packages ##Package cannot access the count variable because it is a private variable.

Package alias

In the Go language, you can create an alias for the imported package. For example, we can name the

fmt package as f and later use f.Println instead of fmt.Println:

import f "fmt"

func main() {
    f.Println("Hello, world!")
}

By creating aliases for packages, we can simplify the code and improve readability.

Non-local package call

In Go language, we can download and install other packages through the

go get command. For example, if you want to install the github.com/gin-gonic/gin package, you can execute the following command:

go get github.com/gin-gonic/gin

After the installation is complete, we can import

gin in the program package to use the functions and variables in it:

import "github.com/gin-gonic/gin"

func main() {
    router := gin.Default()
    router.GET("/", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello, world!")
    })
    router.Run(":8080")
}

Cross-package call

In Go language, if you want to call functions or variables across packages, Need to use package name as prefix. For example, suppose we have a

mylib package and a main package, which respectively define the following functions:

// mylib包
package mylib

func Add(a, b int) int {
    return a + b
}

// main包
package main

import "mylib"

func main() {
    sum := mylib.Add(1, 2)
    println(sum)
}

in the

main package , use the mylib.Add method to call the Add function in the mylib package.

Interface call

In the Go language, an interface is something similar to a protocol, which can define a set of methods that an object needs to implement. If an object implements all methods of an interface, then the object can be considered to implement the interface. For example, we have the following interface:

type Logger interface {
    Log(msg string)
}

If an object wants to implement the

Logger interface, it needs to implement the Log method. For example, we have a structure named FileLogger:

type FileLogger struct {
    file *os.File
}

func (l *FileLogger) Log(msg string) {
    l.file.WriteString(msg)
}

FileLogger The structure implements Log in the Logger interface method, so it can be considered to implement the Logger interface.

In another package, we can define a function

WriteLog, which accepts an object that implements the Logger interface:

func WriteLog(l Logger, msg string) {
    l.Log(msg)
}

us You can use the following method to call the

WriteLog function:

fileLogger := &FileLogger{
    file: os.Create("log.txt"),
}
WriteLog(fileLogger, "hello, world!")

Type assertion

When we use an interface, we need to determine the specific object of an interface type Which type it is can be achieved using type assertions. For example, we have an interface named

HttpResponse:

type HttpResponse interface {
    GetStatus() int
    GetBody() []byte
}

There are two structures

JsonResponse and TextResponse that implement this interface:

type JsonResponse struct {
    status int
    body   []byte
}

func (r *JsonResponse) GetStatus() int {
    return r.status
}

func (r *JsonResponse) GetBody() []byte {
    return r.body
}

type TextResponse struct {
    status int
    body   []byte
}

func (r *TextResponse) GetStatus() int {
    return r.status
}

func (r *TextResponse) GetBody() []byte {
    return r.body
}

We can define a function

SendResponse, which accepts an object that implements the HttpResponse interface.

func SendResponse(resp HttpResponse) {
    fmt.Printf("StatusCode: %d
", resp.GetStatus())
    fmt.Printf("Body: %v
", resp.GetBody())
}

We can call the

SendResponse function in the following way:

jsonResp := &JsonResponse{
    status: 200,
    body:   []byte(`{"message": "hello, world!"}`),
}
SendResponse(jsonResp)

textResp := &TextResponse{
    status: 200,
    body:   []byte("hello, world!"),
}
SendResponse(textResp)

Inside the

SendResponse function, we use type assertion resp. (*JsonResponse) to determine the specific type of the resp object. If the resp object is of type JsonResponse, then the value of the return value ok is true, and the converted resp# will be ##The object is assigned to the json variable; otherwise the value of the return value ok is false. The above are some methods and techniques for calling different packages in Go language. In actual development, making full use of these methods and techniques can improve programming efficiency and reduce the probability of code errors.

The above is the detailed content of Golang different package calls. For more information, please follow other related articles on the PHP Chinese website!