Antara muka Golang kepada penukaran bait

Golang ialah bahasa pengaturcaraan yang ditaip secara statik yang dilancarkan oleh Google yang menyokong mekanisme pengumpulan sampah dan serentak Ia disukai secara meluas dalam pembangunan perisian kerana kesederhanaan, kecekapan dan kebolehpercayaannya. Kekuatan Golang terletak pada mekanisme antara mukanya Melalui antara muka, teknik pengaturcaraan seperti abstraksi, enkapsulasi, dan polimorfisme dapat direalisasikan, dengan itu menjadikan kod lebih ringkas dan fleksibel. Di Golang, antara muka boleh digabungkan dan dibenamkan secara bebas untuk membentuk pelbagai jenis yang kompleks, yang meningkatkan kebolehgunaan semula dan kecekapan kod. Walau bagaimanapun, dalam pembangunan sebenar, kadangkala kita perlu menukar antara muka kepada tatasusunan bait untuk memudahkan penghantaran dan penyimpanan. Jadi, bagaimana untuk melaksanakan operasi menukar antara muka kepada bait dalam Golang? Artikel ini akan memperkenalkan pengetahuan ini secara terperinci.

1. Definisi antara muka

Di Golang, antara muka ialah koleksi kaedah dan tidak mengandungi medan. Jenis antara muka mentakrifkan fungsi, bukan pelaksanaan. Secara khusus, jenis antara muka mentakrifkan satu atau lebih kaedah, yang merupakan satu-satunya ahli antara muka. Nilai sifar untuk jenis antara muka ialah sifar. Antara muka boleh dibenamkan dalam antara muka lain untuk membentuk antara muka komposit.

Antara muka Golang ditaip dengan lemah, yang bermaksud pembolehubah antara muka boleh menyimpan sebarang jenis yang mematuhi definisi antara muka Ini adalah polimorfisme Golang. Tidak seperti bahasa pengaturcaraan lain, polimorfisme di Golang tidak bergantung pada hubungan warisan, tetapi dilaksanakan melalui antara muka. Oleh itu, antara muka adalah salah satu mekanisme terpenting di Golang.

Antara muka ditakrifkan seperti berikut:

type InterfaceName interface {
    Method1Name(param1 T1, param2 T2) ReturnType
    Method2Name(param1 T3, param2 T4) ReturnType
    // ...
}

Antaranya, InterfaceName ialah nama antara muka, Method1Name, Method2Name, dll. ialah senarai kaedah antara muka, T1, T2, T3 , T4 ialah jenis parameter, dan ReturnType ialah jenis nilai pulangan kaedah.

2. Tukar antara muka kepada bait

Di Golang, kami boleh menggunakan beberapa alatan untuk menukar antara muka kepada bait. Berikut adalah beberapa kaedah biasa.

2.1 Gunakan pakej pengekodan/gob

Pakej pengekodan/gob dalam pustaka standard Golang melaksanakan fungsi menukar jenis data Golang kepada tatasusunan bait. Pakej ini menyokong pengekodan pelbagai jenis data Golang ke dalam tatasusunan bait dan boleh menyahkodnya ke dalam jenis data yang sepadan apabila diperlukan. Kami boleh menggunakan antara muka GobEncoder dan GobDecoder dalam pakej ini untuk melaksanakan pengekodan dan penyahkodan jenis tersuai.

Penggunaan khusus adalah seperti berikut:

Tentukan struktur Orang untuk menyimpan maklumat peribadi.

type Person struct {
    Name string
    Age  int
}

Buat pembolehubah Orang, tukarkannya kepada tatasusunan bait.

p := Person{Name: "Eric", Age: 20}
// 创建一个 bytes.Buffer 用于存储编码后的字节流
buf := new(bytes.Buffer)
// 创建一个 gob.Encoder，将 Person 类型编码成字节流
err := gob.NewEncoder(buf).Encode(p)
if err != nil {
    fmt.Println(err)
    return
}

Nyahkod tatasusunan bait ke dalam jenis yang sepadan.

var newP Person
// 创建一个 gob.Decoder，从字节流中解码出 Person 类型
err = gob.NewDecoder(buf).Decode(&newP)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(newP.Name, newP.Age)

Gunakan pakej pengekodan/gob untuk menukar semua jenis tersuai yang melaksanakan antara muka GobEncoder dan GobDecoder kepada tatasusunan bait Anda juga boleh menukar kebanyakan jenis terbina dalam Golang kepada tatasusunan bait. Walau bagaimanapun, pakej ini tidak menyokong penukaran jenis antara muka kepada tatasusunan bait, jadi ia tidak boleh digunakan secara langsung untuk menukar antara muka kepada tatasusunan bait.

2.2 Menggunakan pakej pengekodan/json

Pakej pengekodan/json dalam pustaka standard Golang ialah pakej sokongan untuk pengekodan dan penyahkodan JSON di Golang Ia juga boleh digunakan sebagai alat untuk menukar antara muka kepada bait , yang sangat praktikal dalam beberapa API RESTful.

Tentukan jenis antara muka MyInterface dan cipta struktur MyStruct yang mengandungi antara muka.

type MyInterface interface {
    SayHello() string
}
type MyStruct struct {
    // MyInterface 隐式实现
    MyInterface
}
func (s *MyStruct) SayHello() string {
    return "Hello"
}

Mengekodkan jenis MyStruct ke dalam tatasusunan bait JSON.

s := MyStruct{}
// 创建一个 JSON 编码器，将 MyStruct 类型编码成 JSON 字节数组
b, err := json.Marshal(s)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(string(b))

Menyahkod jenis yang sepadan daripada tatasusunan bait JSON.

var newS MyStruct
// 创建一个 JSON 解码器，从字节数组中解码出 MyStruct 类型
err = json.Unmarshal(b, &newS)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(newS.SayHello())

Pakej pengekodan/json boleh menukar semua jenis tersuai yang melaksanakan antara muka Marshaler dan Unmarshaler kepada tatasusunan bait, dan juga boleh menukar kebanyakan jenis terbina dalam Golang kepada tatasusunan bait. Selain itu, pakej ini menyokong penukaran jenis antara muka kepada tatasusunan bait, jadi ia boleh digunakan untuk menukar antara muka kepada tatasusunan bait.

2.3 Menggunakan rangka kerja bersiri Golang

Terdapat banyak rangka kerja bersiri yang sangat baik di Golang, seperti protobuf, msgpack, dll. Rangka kerja ini boleh menukar jenis data Golang kepada tatasusunan bait. Rangka kerja ini menyediakan antara muka pengekodan dan penyahkodan yang lengkap, menyokong konfigurasi fleksibel dan algoritma bersiri yang cekap, yang menjadikannya sangat mudah untuk menukar antara muka kepada bait dalam Golang.

Mengambil protobuf sebagai contoh, mula-mula tentukan jenis mesej protobuf.

syntax = "proto3";
package main;
message Person {
    string name = 1;
    int32 age = 2;
}

Gunakan alat protok untuk menjana kod Go.

protoc -I=$SRC_DIR --go_out=$DST_DIR $SRC_DIR/person.proto

Menggunakan protobuf di Golang:

p := Person{Name: "Eric", Age: 20}
// 将 Person 类型编码成字节流
pbBytes, err := proto.Marshal(&p)
if err != nil {
    fmt.Println(err)
    return
}
// 将字节流解码成 Person 类型
var newP Person
err = proto.Unmarshal(pbBytes, &newP)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(newP.Name, newP.Age)

Dengan menggunakan rangka kerja bersiri, ia sangat mudah untuk menukar pelbagai jenis data kepada tatasusunan bait, dan kerana kecekapannya yang tinggi, ia adalah praktikal Sangat popular dalam pembangunan.

Ringkasan

Artikel ini memperkenalkan secara terperinci kaedah menukar antara muka kepada tatasusunan bait dalam Golang, termasuk pengekodan/gob, pengekodan/json, rangka kerja siri Golang, dsb., dan menerangkannya secara terperinci Penggunaan dan langkah berjaga-jaga kaedah ini. Kaedah yang berbeza sesuai untuk senario dan keperluan yang berbeza, dan pembangun boleh memilih kaedah yang sesuai mengikut situasi tertentu. Sebagai bahasa pengaturcaraan yang ditaip secara statik, Golang memberi lebih perhatian kepada kebolehbacaan dan kebolehselenggaraan kod semasa melaksanakan penukaran antara muka, yang menjadikan Golang sebagai salah satu bahasa pengaturcaraan yang digemari oleh banyak perusahaan dan projek.

Atas ialah kandungan terperinci Antara muka Golang kepada penukaran bait. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!