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

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

import f "fmt"

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

Non-local package call

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

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

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)
}

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

Interface call

type Logger interface {
    Log(msg string)
}

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.

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

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

WriteLog function:

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

Type assertion

HttpResponse:

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

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
}

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())
}

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)

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!