Hva er refleksjon i Golang

Hva Er Refleksjon I Golang



Refleksjon i Golang lar et program undersøke og endre datastrukturer, typer og verdier under kjøring. Den gir et sett med funksjoner som lar oss undersøke typen og verdien til en hvilken som helst variabel under kjøring, lage nye forekomster av typer og endre verdien av eksisterende variabler. Denne artikkelen dekker forskjellige Golang-funksjoner i reflekterpakken.

Innholdsfortegnelse

Go er et statisk skrevet språk, så typen av en variabel må være kjent på kompileringstidspunktet. I visse scenarier kan det imidlertid være nødvendig å håndtere verdier hvis typer ikke kan bestemmes før programmet er kjørt.







Det kan for eksempel hende vi må skrive en funksjon som kan fungere med ulike typer argumenter, eller vi må kanskje serialisere og deserialisere data av ukjente typer. Det er her reflekterpakken brukes i Golang.



Reflection Package in Go

Refleksjonspakken inneholder et sett med funksjoner som lar oss inspisere og manipulere verdier under kjøring, uavhengig av typen. Med disse funksjonene kan vi få informasjon om typen og verdien til enhver variabel, opprette nye forekomster av typer og endre verdien av eksisterende variabler.



Refleksjonspakken i Golang inneholder to typer: Type og verdi. En Type representerer en Go-type, for eksempel int, streng eller en egendefinert struktur. En verdi representerer en verdi av en bestemt type, for eksempel 42 eller 'hei'.





Refleksjonspakken gir også et sett med funksjoner som lar oss hente Type- og Value-objekter fra variabler. For eksempel returnerer reflect.TypeOf()-funksjonen et Type-objekt som representerer typen til en variabel, mens reflect.ValueOf()-funksjonen gir et Value-objekt som viser variabelverdi.

I de følgende delene vil vi utforske noen av de mest brukte funksjonene i reflekterpakken.



reflect.Copy() funksjon

reflect.Copy()-funksjonen til reflect-pakken brukes til å kopiere verdiene til en skive til en annen skive. Det krever to parametere, dst og src, som begge må være stykkeverdier med samme elementtype. Funksjonen kopierer verdiene fra src-delen til dst-delen og returnerer antall elementer som ble kopiert.

Funksjonen reflect.Copy() er demonstrert i følgende eksempel:

pakke hoved-

import (

'fmt'
'reflektere'
)
func hoved- () {
src := [] int { 1 , 2 , 3 , 4 , 5 }
dst := gjøre ([] int , bare ( src ))
n := reflektere . Kopiere ( reflektere . Verdien av ( dst ), reflektere . Verdien av ( src ))
fmt . Println ( n ) // Utgang: 5
fmt . Println ( dst ) // Utdata: [1 2 3 4 5]


}

I dette eksemplet lager vi en kildedel src med noen heltallsverdier, og en destinasjonsdel dst med samme lengde som src. Vi kaller deretter reflect.Copy() for å kopiere verdiene fra src til dst og skrive ut antall elementer som ble kopiert (n) og innholdet i dst-skiven.

reflect.DeepEqual() funksjon

reflect.DeepEqual()-funksjonen til reflect-pakken brukes til å sammenligne to verdier for likhet. Denne funksjonen har to inngangsparametere som er a og b, som begge kan ha en hvilken som helst verdi av hvilken som helst type. Funksjonen returnerer sann hvis a og b er dypt like, noe som betyr at deres underliggende verdier er rekursivt like. Ellers viser det seg å være usant.

Følgende eksempel viser hvordan du bruker reflect.DeepEqual():

pakke hoved-

import (

'fmt'
'reflektere'
)
func hoved- () {
en := [] int { 1 , 2 , 3 }
b := [] int { 1 , 2 , 3 }
hvis reflektere . DeepEqual ( en , b ) {
fmt . Println ( 'a og b er like' )
} ellers {
fmt . Println ( 'a og b er ikke like' )
}


}

I dette eksemplet lager vi to skiver a og b med samme heltallsverdier. Vi kaller deretter reflect.DeepEqual() for å sammenligne a og b for likhet og skrive ut resultatet.

reflect.Swapper() Funksjon

reflect.Swapper()-funksjonen til reflect-pakken brukes til å returnere en funksjon som kan bytte ut elementene i en skive. Det krever en enkelt parameter, v, som må være en skiveverdi. Funksjonen returnerer en funksjon som tar to heltallsparametere, i og j, og bytter elementene i snittet ved posisjonene i og j.

Bruken av reflect.Swapper() kan demonstreres gjennom følgende eksempel:

pakke hoved-

import (

'fmt'
'reflektere'
)
func hoved- () {
s := [] int { 1 , 2 , 3 , 4 , 5 }
bytte := reflektere . Bytter ( s )
bytte ( 1 , 3 )
fmt . Println ( s ) // Utdata: [1 4 3 2 5]


}

I dette eksemplet opprettet vi en skive kalt s med noen heltallsverdier. Vi kaller deretter reflect.Swapper() for å få en funksjonsswap som kan bytte elementer av snittet. Vi bruker swap for å bytte elementene på posisjon 1 og 3 av s-skiven og skrive ut resultatet.

reflect.TypeOf() funksjon

Refleksjon.TypeOf() brukes til å få typen til en verdi. Denne funksjonen aksepterer en enkelt parameter 'v' som kan være av hvilken som helst type eller verdi. Funksjonen returnerer en reflect.Type-verdi som representerer typen til verdien.

Bruken av reflect.TypeOf() kan demonstreres gjennom følgende eksempel:

pakke hoved-

import (

'fmt'
'reflektere'
)
func hoved- () {
var x flyte64 = 3 . 14
t := reflektere . TypeOf ( x )
fmt . Println ( t ) // Utgang: float64


}

I dette eksemplet lager vi en float64-variabel x med verdien 3.14. Vi kaller deretter reflect.TypeOf() for å få typen x og lagre resultatet i en reflect.Type-variabel t. Vi skriver ut verdien av t, som er float64.

reflect.ValueOf() funksjon

reflect.ValueOf() kan få en reflect.Value-representasjon av en verdi. Det krever en enkelt parameter v, som kan være en hvilken som helst verdi av hvilken som helst type. Funksjonen returnerer en reflect.Value-verdi som representerer verdien til inngangsparameteren.

Bruken av reflect.ValueOf() kan demonstreres gjennom følgende eksempel:

pakke hoved-

import (

'fmt'
'reflektere'
)
func hoved- () {
var x flyte64 = 3 . 14
i := reflektere . Verdien av ( x )
fmt . Println ( i ) // Utgang: 3,14

}

I dette eksemplet lager vi en float64-variabel x med verdien 3.14. Vi kaller deretter reflect.ValueOf() for å få en reflektert verdi-representasjon av x og lagrer resultatet i en reflektert-verdi-variabel v. Vi skriver ut verdien av v, som er 3,14.

Refleksjonspakken gir en rekke funksjoner utover de som er nevnt, og dette er bare noen få eksempler. Ved å bruke funksjonene som tilbys av reflect-pakken, kan vi lage kode som kan fungere med verdier av enhver type, uten å måtte vite typen på kompileringstidspunktet.

Konklusjon

Refleksjon i Golang lar et program undersøke og endre datastrukturer, typer og verdier under kjøring. Den implementeres gjennom reflect-pakken, som gir funksjoner for å inspisere og manipulere typer og verdier. Refleksjon er spesielt nyttig når du arbeider med grensesnitt, ukjente typer, eller når du trenger å implementere generiske funksjoner. Denne artikkelen diskuterte det grunnleggende om refleksjon i Golang, inkludert reflekteringspakken, reflekterende type og verdi, og dynamisk type og verdi.