Ang Reflection sa Golang ay nagbibigay-daan sa isang programa na suriin at baguhin ang mga istruktura, uri, at halaga ng data sa runtime. Nagbibigay ito ng isang hanay ng mga function na nagbibigay-daan sa amin upang suriin ang uri at halaga ng anumang variable sa runtime, lumikha ng mga bagong pagkakataon ng mga uri, at baguhin ang halaga ng mga umiiral na variable. Sinasaklaw ng artikulong ito ang iba't ibang function ng Golang sa reflect package.
Talaan ng mga Nilalaman
- Reflect Package sa Go
- reflect.Copy() Function
- reflect.DeepEqual() Function
- reflect.Swapper() Function
- reflect.TypeOf() Function
- reflect.ValueOf() Function
- Konklusyon
Ang Go ay isang statically typed na wika kaya dapat malaman ang uri ng variable sa oras ng compile. Gayunpaman, sa ilang partikular na sitwasyon, maaaring kailanganin na pangasiwaan ang mga halaga na ang mga uri ay hindi matutukoy hanggang sa maisakatuparan ang programa.
Halimbawa, maaaring kailanganin naming magsulat ng isang function na maaaring gumana sa iba't ibang uri ng mga argumento, o maaaring kailanganin naming i-serialize at i-deserialize ang data ng mga hindi kilalang uri. Dito ginagamit ang reflect package sa Golang.
Reflect Package sa Go
Ang reflect package ay nagbibigay ng isang hanay ng mga function na nagbibigay-daan sa amin upang siyasatin at manipulahin ang mga halaga sa runtime, anuman ang kanilang mga uri. Sa mga function na ito, makakakuha tayo ng impormasyon tungkol sa uri at halaga ng anumang variable, lumikha ng mga bagong pagkakataon ng mga uri, at baguhin ang halaga ng mga umiiral na variable.
Ang reflect package sa Golang ay naglalaman ng dalawang uri: Uri at Halaga. Ang isang Uri ay kumakatawan sa isang uri ng Go, gaya ng int, string, o isang custom na struct. Ang isang Value ay kumakatawan sa isang halaga ng isang partikular na uri, tulad ng 42 o 'hello'.
Ang reflect package ay nagbibigay din ng isang set ng mga function na nagbibigay-daan sa amin upang makakuha ng Type at Value objects mula sa mga variable. Halimbawa, ang reflect.TypeOf() function ay nagbabalik ng Type object na kumakatawan sa uri ng variable, habang ang reflect.ValueOf() function ay nagbibigay ng Value object na nagpapakita ng variable na value.
Sa mga sumusunod na seksyon, tutuklasin namin ang ilan sa mga karaniwang ginagamit na function sa reflect package.
reflect.Copy() Function
Ang reflect.Copy() function ng reflect package ay ginagamit upang kopyahin ang mga value ng isang slice sa isa pang slice. Kailangan ng dalawang parameter, dst, at src, na parehong dapat ay mga slice value na may parehong uri ng elemento. Kinokopya ng function ang mga value mula sa src slice papunta sa dst slice at ibinabalik ang bilang ng mga elementong nakopya.
Ang reflect.Copy() function ay ipinapakita sa sumusunod na halimbawa:
pakete pangunahingangkat (
'fmt'
'magmuni-muni'
)
func pangunahing () {
src := [] int { 1 , 2 , 3 , 4 , 5 }
dst := gumawa ([] int , lamang ( src ))
n := sumasalamin . Kopya ( sumasalamin . ValueOf ( dst ), sumasalamin . ValueOf ( src ))
fmt . Println ( n ) // Output: 5
fmt . Println ( dst ) // Output: [1 2 3 4 5]
}
Sa halimbawang ito, gumawa kami ng source slice src na may ilang integer value, at destination slice dst na may parehong haba ng src. Pagkatapos ay tinawag namin ang reflect.Copy() upang kopyahin ang mga halaga mula sa src hanggang dst at i-print ang bilang ng mga elemento na kinopya (n) at ang mga nilalaman ng dst slice.
reflect.DeepEqual() Function
Ang reflect.DeepEqual() function ng reflect package ay ginagamit upang paghambingin ang dalawang value para sa pagkakapantay-pantay. Ang function na ito ay may dalawang input parameter na a at b, na parehong maaaring maging anumang halaga ng anumang uri. Ang function ay nagbabalik ng true kung ang a at b ay malalim na pantay, ibig sabihin ang kanilang mga pinagbabatayan na halaga ay recursively pantay. Kung hindi, ito ay lumalabas na hindi totoo.
Ang sumusunod na halimbawa ay nagpapakita kung paano gamitin ang reflect.DeepEqual():
pakete pangunahingangkat (
'fmt'
'magmuni-muni'
)
func pangunahing () {
a := [] int { 1 , 2 , 3 }
b := [] int { 1 , 2 , 3 }
kung sumasalamin . DeepEqual ( a , b ) {
fmt . Println ( 'ang a at b ay pantay' )
} iba pa {
fmt . Println ( 'ang a at b ay hindi pantay' )
}
}
Sa halimbawang ito, lumikha kami ng dalawang hiwa a at b na may parehong mga halaga ng integer. Pagkatapos ay tinatawagan namin ang reflect.DeepEqual() upang ihambing ang a at b para sa pagkakapantay-pantay at i-print ang resulta.
reflect.Swapper() Function
Ang reflect.Swapper() function ng reflect package ay ginagamit upang ibalik ang isang function na maaaring magpalit ng mga elemento ng isang slice. Kailangan ng isang parameter, v, na dapat ay isang slice value. Ang function ay nagbabalik ng isang function na kumukuha ng dalawang integer parameter, i at j, at pinapalitan ang mga elemento ng slice sa mga posisyong i at j.
Ang paggamit ng reflect.Swapper() ay maaaring ipakita sa pamamagitan ng sumusunod na halimbawa:
pakete pangunahingangkat (
'fmt'
'magmuni-muni'
)
func pangunahing () {
s := [] int { 1 , 2 , 3 , 4 , 5 }
magpalit := sumasalamin . Swapper ( s )
magpalit ( 1 , 3 )
fmt . Println ( s ) // Output: [1 4 3 2 5]
}
Sa halimbawang ito, gumawa kami ng slice na pinangalanang s na may ilang integer value. Pagkatapos ay tinawag namin ang reflect.Swapper() upang makakuha ng function swap na maaaring magpalit ng mga elemento ng slice. Gumagamit kami ng swap upang ipagpalit ang mga elemento sa mga posisyon 1 at 3 ng s slice at i-print ang resulta.
reflect.TypeOf() Function
Ang reflect.TypeOf() ay ginagamit upang makuha ang uri ng isang halaga. Ang function na ito ay tumatanggap ng isang parameter na 'v' na maaaring maging anumang uri o halaga. Nagbabalik ang function ng reflect.Type value na kumakatawan sa uri ng value.
Ang paggamit ng reflect.TypeOf() ay maaaring ipakita sa pamamagitan ng sumusunod na halimbawa:
pakete pangunahingangkat (
'fmt'
'magmuni-muni'
)
func pangunahing () {
ay x lumutang64 = 3 . 14
t := sumasalamin . Uri ng ( x )
fmt . Println ( t ) // Output: float64
}
Sa halimbawang ito, lumikha kami ng float64 variable x na may halagang 3.14. Pagkatapos ay tinawag namin ang reflect.TypeOf() upang makuha ang uri ng x at iimbak ang resulta sa isang reflect.Type variable t. Ini-print namin ang halaga ng t, na float64.
reflect.ValueOf() Function
Ang reflect.ValueOf() ay maaaring makakuha ng reflect.Value na representasyon ng isang value. Kailangan ng isang parameter v, na maaaring maging anumang halaga ng anumang uri. Nagbabalik ang function ng reflect.Value value na kumakatawan sa value ng input parameter.
Ang paggamit ng reflect.ValueOf() ay maaaring ipakita sa pamamagitan ng sumusunod na halimbawa:
pakete pangunahingangkat (
'fmt'
'magmuni-muni'
)
func pangunahing () {
ay x lumutang64 = 3 . 14
sa := sumasalamin . ValueOf ( x )
fmt . Println ( sa ) // Output: 3.14
}
Sa halimbawang ito, lumikha kami ng float64 variable x na may halagang 3.14. Pagkatapos ay tinawag namin ang reflect.ValueOf() upang makakuha ng representasyon ng reflect-value ng x at iimbak ang resulta sa isang variable na reflect-value v. Ini-print namin ang halaga ng v, na 3.14.
Ang reflect package ay nagbibigay ng maraming mga function na lampas sa mga nabanggit, at ito ay ilan lamang sa mga halimbawa. Sa pamamagitan ng paggamit ng mga function na ibinigay ng reflect package, maaari kaming lumikha ng code na maaaring gumana sa mga halaga ng anumang uri, nang hindi kinakailangang malaman ang uri sa oras ng pagsasama-sama.
Konklusyon
Ang Reflection sa Golang ay nagbibigay-daan sa isang programa na suriin at baguhin ang mga istruktura, uri, at halaga ng data sa runtime. Ito ay ipinatupad sa pamamagitan ng reflect package, na nagbibigay ng mga function upang siyasatin at manipulahin ang mga uri at halaga. Ang pagninilay ay lalong kapaki-pakinabang kapag nagtatrabaho sa mga interface, hindi kilalang mga uri, o kapag kailangan mong ipatupad ang mga generic na function. Tinalakay ng artikulong ito ang mga pangunahing kaalaman sa pagmuni-muni sa Golang, kabilang ang reflect package, reflect Type at Value, at dynamic na uri at value.