kaedah refleksi golang

1. Konsep refleksi

Dalam pengaturcaraan, refleksi merujuk kepada kebolehan untuk mendapatkan maklumat struktur atur cara semasa runtime. Penjelasan mudah ialah program boleh menyemak status, sifat dan kaedahnya sendiri pada masa jalan tanpa perlu menentukan semua maklumat ini pada masa penyusunan. Refleksi membolehkan program bahasa Go mempunyai fleksibiliti dan keupayaan yang serupa dengan bahasa dinamik lain.

Dalam bahasa Go, untuk melaksanakan refleksi, anda boleh menggunakan pakej reflect, yang menyediakan sejumlah besar meta-maklumat tentang jenis dan nilai, yang boleh digunakan secara dinamik semasa program dijalankan.

2. Aplikasi refleksi

Refleksi mempunyai pelbagai senario aplikasi dalam bahasa Go. Contohnya:

1 Apabila menulis fungsi umum, sukar untuk meramal jenis parameter masuk tertentu, jadi anda boleh menggunakan refleksi untuk mendapatkan maklumat parameter masuk secara dinamik.

2. Apabila menulis rangka kerja ORM, anda boleh memetakan objek secara automatik ke jadual dalam pangkalan data, atau anda boleh menanyakan data daripada pangkalan data dan menggunakan refleksi untuk memetakan objek yang sepadan secara automatik.

3. Banyak rangka kerja dan alatan menggunakan refleksi untuk membaca fail konfigurasi atau menghuraikan parameter arahan.

3. Jenis pantulan

Dalam bahasa Go, terdapat dua jenis pantulan utama:

1.Type

Type is type information , yang mewakili jenis dalam Go, yang boleh menjadi jenis data asas, struktur, fungsi, penunjuk, tatasusunan, hirisan, antara muka, dsb.

2.Nilai

Nilai mewakili nilai, yang boleh menjadi sebarang jenis nilai Ia membungkus nilai data dan maklumat jenis, dan menyediakan satu siri kaedah operasi.

4. Operasi asas pantulan

1 Dapatkan maklumat jenis

Gunakan fungsi reflect.TypeOf() untuk mendapatkan maklumat jenis bagi sebarang nilai berikut:

func TypeOf(i interface{}) Type

Sebagai contoh, kami ingin mendapatkan maklumat jenis rentetan "hello":

t := reflect.TypeOf("hello")
fmt.Println(t.Kind())  // 输出：string

2. Dapatkan maklumat nilai

Gunakan reflect.ValueOf () berfungsi untuk mendapatkan maklumat nilai sebarang nilai , sintaksnya adalah seperti berikut:

func ValueOf(i interface{}) Value

Sebagai contoh, kami ingin mendapatkan maklumat nilai pembolehubah rentetan "hello":

value := reflect.ValueOf("hello")
fmt.Println(value.String()) // 输出：hello

3. Dapatkan maklumat jenis dan nilai pembolehubah

Jika anda mahu Untuk mendapatkan maklumat jenis dan nilai pembolehubah pada masa yang sama, anda boleh menggunakan kaedah reflect.TypeOf() dan reflect.ValueOf() bersama-sama, seperti berikut:

var age int = 22
t := reflect.TypeOf(age)                // 变量类型信息
v := reflect.ValueOf(age)               // 变量值信息
fmt.Println(t.Kind(), v.Int())          // 输出：int 22

4 Tetapkan nilai pembolehubah melalui pantulan

gunakan Refleksi boleh mengubah suai nilai pembolehubah secara dinamik Anda perlu menggunakan kaedah jenis Nilai Set() dalam pakej reflect. Sintaks adalah seperti berikut:

func (v Value) Set(x Value)

Antaranya, jenis parameter x harus konsisten dengan jenis v, jika tidak ralat akan dilaporkan.

Sebagai contoh, kami menukar nilai pembolehubah umur kepada 33:

v := reflect.ValueOf(&age)
v.Elem().SetInt(33)
fmt.Println(age)                     // 输出：33

5 Ubah suai nilai ahli struktur melalui refleksi

Gunakan refleksi untuk mengubah suai secara dinamik. ahli struktur Untuk nilai, anda perlu menggunakan jenis Nilai dalam pakej mencerminkan dan kaedah FieldByName() dalam jenis Jenis Sintaks adalah seperti berikut:

func (v Value) FieldByName(name string) Value

Sebagai contoh, kami mentakrifkan struktur Orang dan mengubah suai. nilai nama dan umur ahlinya:

type Person struct {
    name string
    age  int
}

func main() {
    p := Person{name: "Mike", age: 22}
    v := reflect.ValueOf(&p).Elem()
    v.FieldByName("name").SetString("Tom")
    v.FieldByName("age").SetInt(33)
    fmt.Println(p)                         // 输出：{Tom 33}
}

6 Memanggil fungsi melalui refleksi

Menggunakan refleksi untuk memanggil fungsi secara dinamik, anda perlu menggunakan jenis Nilai dalam pakej mencerminkan dan kaedah Panggilan() dalam jenis Jenis Sintaks adalah seperti berikut:

func (v Value) Call(args []Value) []Value

Antaranya, parameter args ialah parameter input fungsi, dan nilai pulangan ialah parameter output fungsi.

Sebagai contoh, kami mentakrifkan fungsi Tambah dan memanggil fungsi Tambah melalui pantulan:

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

func main() {
    var params []reflect.Value
    params = append(params, reflect.ValueOf(1))
    params = append(params, reflect.ValueOf(2))
    result := reflect.ValueOf(Add).Call(params)
    fmt.Println(result[0].Int())           // 输出：3
}

Di atas adalah operasi asas pantulan dalam bahasa Go yang memberikan keupayaan yang lebih berkuasa kepada bahasa Go dan Fleksibiliti, kita juga boleh menggunakan refleksi secara fleksibel untuk melaksanakan beberapa fungsi semasa pembangunan.

Atas ialah kandungan terperinci kaedah refleksi golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!