Golang panggilan pakej berbeza

Bahasa Go ialah bahasa pengaturcaraan sumber terbuka Kemunculannya mempunyai banyak kelebihan, termasuk pemeriksaan jenis statik, pengumpulan sampah dan coroutine, dsb. Apabila membangun dalam bahasa Go, adalah keperluan biasa untuk menggunakan fungsi dan pembolehubah daripada pakej yang berbeza. Artikel ini akan memperkenalkan beberapa kaedah dan teknik untuk memanggil pakej yang berbeza dalam bahasa Go.

1. Import pakej yang diperlukan

Dalam bahasa Go, kita perlu menggunakan pernyataan import untuk mengimport pakej yang diperlukan. Sebagai contoh, jika kita ingin menggunakan fungsi dalam pakej fmt, maka kita boleh mengimport pakej fmt dalam kod:

import "fmt"

Jika kita ingin mengimport berbilang pakej pada masa yang sama, kita boleh gunakan kaedah berikut:

import (
    "fmt"
    "time"
)

Perlu diambil perhatian bahawa nama pakej yang diimport mestilah unik. Apabila menggunakan fungsi dan pembolehubah dalam pakej, anda perlu menggunakan awalan nama pakej untuk mengaksesnya.

2. Keterlihatan Pakej

Dalam bahasa Go, keterlihatan pembolehubah, fungsi, pemalar, dsb. dikawal oleh kes huruf pertama. Jika huruf pertama pembolehubah yang kita takrifkan adalah huruf besar, maka pembolehubah itu boleh diakses oleh pakej luaran, jika tidak, ia tidak boleh diakses oleh pakej luaran. Sebagai contoh, kami mentakrifkan fungsi berikut:

func GetUserId() string {
    // TODO
}

Memandangkan huruf pertama nama fungsi GetUserId ditulis dengan huruf besar, fungsi ini boleh diakses oleh pakej lain.

Apabila kami mengimport pakej, hanya fungsi dan pembolehubah yang terdedah dalam pakej boleh diakses. Sebagai contoh, katakan kita mempunyai pakej bernama mylib, yang mempunyai pembolehubah peribadi count:

package mylib

var count int = 0

Jika kami mengimport pakej mylib dalam pakej lain, kami tidak boleh mengakses pembolehubah count , kerana ia adalah pembolehubah persendirian.

3. Alias ​​pakej

Dalam bahasa Go, anda boleh mencipta alias untuk pakej yang diimport. Sebagai contoh, kita boleh menamakan pakej fmt f dan kemudian menggunakan f.Println bukannya fmt.Println:

import f "fmt"

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

Dengan mencipta alias untuk pakej, kami boleh memudahkan kod dan meningkatkan kebolehbacaan.

4. Panggilan pakej bukan setempat

Dalam bahasa Go, kami boleh memuat turun dan memasang pakej lain melalui perintah go get. Sebagai contoh, jika anda ingin memasang pakej github.com/gin-gonic/gin, anda boleh melaksanakan arahan berikut:

go get github.com/gin-gonic/gin

Selepas pemasangan selesai, kami boleh menggunakan fungsi dan pembolehubah dalam program dengan mengimport gin pakej:

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

5. Panggilan silang pakej

Dalam bahasa Go, jika anda ingin memanggil fungsi atau pembolehubah merentas pakej, anda perlu menggunakan nama pakej sebagai awalan. Sebagai contoh, katakan kita mempunyai pakej mylib dan pakej main, yang masing-masing mentakrifkan fungsi berikut:

// mylib包
package mylib

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

rrree

Dalam pakej main, gunakan kaedah mylib.Add untuk memanggil mylib Add berfungsi dalam pakej.

6. Panggilan antara muka

Dalam bahasa Go, antara muka adalah sesuatu yang serupa dengan protokol, yang boleh mentakrifkan satu set kaedah yang perlu dilaksanakan oleh objek. Jika objek melaksanakan semua kaedah antara muka, maka objek boleh dipertimbangkan untuk melaksanakan antara muka. Sebagai contoh, kami mempunyai antara muka berikut:

// main包
package main

import "mylib"

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

Jika objek ingin melaksanakan antara muka Logger, ia perlu melaksanakan kaedah Log. Sebagai contoh, kami mempunyai struktur bernama FileLogger:

type Logger interface {
    Log(msg string)
}

FileLogger Struktur tersebut melaksanakan kaedah Logger dalam antara muka Log, jadi ia boleh dipertimbangkan untuk melaksanakan antara muka Logger .

Dalam pakej lain, kita boleh mentakrifkan fungsi WriteLog, yang menerima objek yang melaksanakan antara muka Logger:

type FileLogger struct {
    file *os.File
}

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

Kita boleh memanggilnya dengan cara berikut WriteLogFungsi :

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

7. Type Assertion

Apabila kita menggunakan antara muka, kita perlu menentukan jenis objek tertentu jenis antara muka Kita boleh menggunakan penegasan jenis untuk dicapai ini. Sebagai contoh, kami mempunyai antara muka bernama HttpResponse:

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

Terdapat dua struktur JsonResponse dan TextResponse yang melaksanakan antara muka ini:

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

Kita boleh mentakrifkan fungsi SendResponse , fungsi ini menerima objek yang melaksanakan antara muka HttpResponse.

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
}

Kita boleh memanggil fungsi SendResponse dengan cara berikut:

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

Di dalam fungsi SendResponse, kami menggunakan penegasan jenis resp.(*JsonResponse) untuk menentukan jenis khusus resp objek. Jika objek resp adalah jenis JsonResponse, maka nilai nilai pulangan ok ialah true dan objek resp yang ditukar diperuntukkan kepada pembolehubah json jika tidak, nilai bagi nilai pulangan ok ialah false.

Di atas ialah beberapa kaedah dan teknik untuk memanggil pakej yang berbeza dalam bahasa Go. Dalam pembangunan sebenar, menggunakan sepenuhnya kaedah dan teknik ini boleh meningkatkan kecekapan pengaturcaraan dan mengurangkan kebarangkalian ralat kod.

Atas ialah kandungan terperinci Golang panggilan pakej berbeza. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!