Rumah >pembangunan bahagian belakang >Golang >[Ringkasan] Beberapa penggunaan pantulan Golang biasa
Golang ialah bahasa pengaturcaraan yang ditaip secara statik, tetapi ia juga menyediakan mekanisme pantulan yang boleh mendapatkan maklumat jenis pembolehubah semasa masa jalan, serta memanggil kaedah secara dinamik dan mengubah suai sifat. Refleksi ialah ciri biasa dalam pengaturcaraan Golang Artikel ini akan memperkenalkan beberapa penggunaan pantulan Golang yang biasa.
Refleksi ialah ciri penting Golang, yang membolehkan program mengenal pasti jenis objek secara dinamik dan melaksanakan operasi pada masa jalan. Melalui refleksi, kita boleh mengakses semua ahli, kaedah, label dan maklumat lain struktur.
Di Golang, refleksi boleh digunakan untuk menyelesaikan tiga tugasan berikut:
refleksi dilaksanakan terutamanya oleh pustaka standard reflect
Dengan memanggil beberapa kaedah dalam pustaka reflect
, anda boleh mendapatkan jenis dan nilai pembolehubah dan maklumat lain yang berkaitan.
Melalui refleksi, kita boleh mendapatkan maklumat jenis mana-mana pembolehubah. Berikut ialah contoh untuk mendapatkan jenis pembolehubah:
package main import ( "fmt" "reflect" ) func main() { var num int = 100 fmt.Println(reflect.TypeOf(num)) }
Menjalankan kod di atas akan mengeluarkan jenis num
pembolehubah int
.
Di Golang, anda boleh mendapatkan nilai sebenar sebarang pembolehubah melalui pantulan. Berikut ialah contoh mendapatkan nilai pembolehubah:
package main import ( "fmt" "reflect" ) func main() { var num int = 100 fmt.Println(reflect.ValueOf(num)) }
Menjalankan kod di atas akan mengeluarkan nilai num
pembolehubah 100
.
Melalui refleksi, kita bukan sahaja boleh mendapatkan jenis dan nilai pembolehubah, tetapi juga mengubah suai nilai pembolehubah. Berikut ialah contoh mengubah suai nilai pembolehubah:
package main import ( "fmt" "reflect" ) func main() { var num int = 100 fmt.Println("before:", num) value := reflect.ValueOf(&num) value.Elem().SetInt(200) fmt.Println("after:", num) }
Menjalankan kod di atas akan mengeluarkan nilai pembolehubah num
sebelum dan selepas pengubahsuaian.
Di Golang, kita boleh mendapatkan maklumat ahli struktur melalui refleksi. Berikut ialah contoh mendapatkan maklumat ahli struktur:
package main import ( "fmt" "reflect" ) type User struct { Name string Age int } func main() { user := &User{Name: "Tom", Age: 18} t := reflect.TypeOf(user).Elem() for i := 0; i < t.NumField(); i++ { field := t.Field(i) fmt.Println(field.Name) fmt.Println(field.Type) fmt.Println(field.Tag) } }
Menjalankan kod di atas akan mengeluarkan semua maklumat ahli struktur User
.
Melalui refleksi, kita boleh memanggil fungsi secara dinamik. Berikut ialah contoh memanggil fungsi secara dinamik:
package main import ( "fmt" "reflect" ) func Sum(a, b int) int { return a + b } func main() { fn := reflect.ValueOf(Sum) args := []reflect.Value{reflect.ValueOf(1), reflect.ValueOf(2)} result := fn.Call(args) fmt.Println(result[0].Int()) }
Menjalankan kod di atas akan mengeluarkan hasil Sum
yang dikira oleh fungsi 3
. Dalam fungsi Call
, parameter args
ialah kepingan, yang menyimpan nilai parameter fungsi. Dengan cara yang sama, anda juga boleh menggunakan reflect.ValueOf
untuk memanggil kaedah secara dinamik. Walau bagaimanapun, perlu diingatkan bahawa parameter pertama kaedah ialah objek penerima, yang perlu dibalut dengan reflect.ValueOf
.
Artikel ini memperkenalkan kegunaan biasa pantulan Golang, termasuk mendapatkan jenis pembolehubah, mendapatkan nilai pembolehubah, mengubah suai nilai pembolehubah, mendapatkan maklumat ahli struktur, fungsi panggilan secara dinamik, dsb. Saya percaya penggunaan pantulan ini boleh membantu anda memahami dan menggunakan mekanisme pantulan Golang dengan lebih baik.
Atas ialah kandungan terperinci [Ringkasan] Beberapa penggunaan pantulan Golang biasa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!