Reflektion i Golang tillåter ett program att undersöka och ändra datastrukturer, typer och värden vid körning. Den tillhandahåller en uppsättning funktioner som gör att vi kan undersöka typen och värdet för valfri variabel vid körning, skapa nya instanser av typer och ändra värdet på befintliga variabler. Den här artikeln täcker olika Golang-funktioner i reflektionspaketet.
Innehållsförteckning
- Reflection Package in Go
- reflect.Copy() Funktion
- reflect.DeepEqual() Funktion
- reflect.Swapper() Funktion
- reflect.TypeOf() Funktion
- reflect.ValueOf() Funktion
- Slutsats
Go är ett statiskt skrivet språk så typen av en variabel måste vara känd vid kompileringstillfället. Men i vissa scenarier kan det vara nödvändigt att hantera värden vars typer inte kan fastställas förrän programmet körs.
Till exempel kan vi behöva skriva en funktion som kan fungera med olika typer av argument, eller så kan vi behöva serialisera och deserialisera data av okända typer. Det är här reflekteringspaketet används i Golang.
Reflection Package in Go
Reflektionspaketet tillhandahåller en uppsättning funktioner som gör att vi kan inspektera och manipulera värden under körning, oavsett deras typ. Med dessa funktioner kan vi få information om typen och värdet för valfri variabel, skapa nya instanser av typer och ändra värdet på befintliga variabler.
Reflektionspaketet i Golang innehåller två typer: Typ och värde. En Typ representerar en Go-typ, till exempel int, sträng eller en anpassad struktur. Ett värde representerar ett värde av en specifik typ, till exempel 42 eller 'hej'.
Reflektionspaketet tillhandahåller också en uppsättning funktioner som gör att vi kan hämta Type- och Value-objekt från variabler. Till exempel returnerar funktionen reflect.TypeOf() ett Type-objekt som representerar typen av en variabel, medan funktionen reflect.ValueOf() ger ett Value-objekt som visar variabelvärdet.
I följande avsnitt kommer vi att utforska några av de vanligaste funktionerna i reflektionspaketet.
reflect.Copy() Funktion
funktionen reflect.Copy() för reflect-paketet används för att kopiera värdena för en skiva till en annan skiva. Det krävs två parametrar, dst och src, som båda måste vara segmentvärden med samma elementtyp. Funktionen kopierar värdena från src-delen till dst-delen och returnerar antalet element som kopierades.
Funktionen reflect.Copy() visas i följande exempel:
paket huvudimportera (
'fmt'
'reflektera'
)
func huvud () {
src := [] int { 1 , 2 , 3 , 4 , 5 }
dst := göra ([] int , endast ( src ))
n := reflektera . Kopiera ( reflektera . Värdet av ( dst ), reflektera . Värdet av ( src ))
fmt . Println ( n ) // Utdata: 5
fmt . Println ( dst ) // Utdata: [1 2 3 4 5]
}
I det här exemplet skapar vi ett källsegment src med några heltalsvärden och ett destinationssegment dst med samma längd som src. Vi anropar sedan reflect.Copy() för att kopiera värdena från src till dst och skriva ut antalet element som kopierades (n) och innehållet i dst-delen.
reflect.DeepEqual() Funktion
funktionen reflect.DeepEqual() för reflect-paketet används för att jämföra två värden för likhet. Denna funktion har två ingångsparametrar som är a och b, som båda kan vara av vilket värde som helst av vilken typ som helst. Funktionen returnerar sant om a och b är djupt lika, vilket betyder att deras underliggande värden är rekursivt lika. Annars visar det sig vara falskt.
Följande exempel visar hur du använder reflect.DeepEqual():
paket huvudimportera (
'fmt'
'reflektera'
)
func huvud () {
a := [] int { 1 , 2 , 3 }
b := [] int { 1 , 2 , 3 }
om reflektera . DeepEqual ( a , b ) {
fmt . Println ( 'a och b är lika' )
} annan {
fmt . Println ( 'a och b är inte lika' )
}
}
I det här exemplet skapar vi två skivor a och b med samma heltalsvärden. Vi anropar sedan reflect.DeepEqual() för att jämföra a och b för likhet och skriva ut resultatet.
reflect.Swapper() Funktion
reflect.Swapper()-funktionen för reflect-paketet används för att returnera en funktion som kan byta elementen i en skiva. Det krävs en enda parameter, v, som måste vara ett segmentvärde. Funktionen returnerar en funktion som tar två heltalsparametrar, i och j, och byter ut elementen i segmentet vid positionerna i och j.
Användningen av reflect.Swapper() kan demonstreras genom följande exempel:
paket huvudimportera (
'fmt'
'reflektera'
)
func huvud () {
s := [] int { 1 , 2 , 3 , 4 , 5 }
byta := reflektera . Bytare ( s )
byta ( 1 , 3 )
fmt . Println ( s ) // Utdata: [1 4 3 2 5]
}
I det här exemplet skapade vi en skiva med namnet s med några heltalsvärden. Vi anropar sedan reflect.Swapper() för att få en funktionsswap som kan byta delar av segmentet. Vi använder swap för att byta elementen på position 1 och 3 i s-skivan och skriva ut resultatet.
reflect.TypeOf() Funktion
Reflect.TypeOf() används för att få typen av ett värde. Den här funktionen accepterar en enda parameter 'v' som kan vara av vilken typ eller värde som helst. Funktionen returnerar ett reflect.Type-värde som representerar typen av värdet.
Användningen av reflect.TypeOf() kan demonstreras genom följande exempel:
paket huvudimportera (
'fmt'
'reflektera'
)
func huvud () {
var x flyta64 = 3 . 14
t := reflektera . Sorts ( x )
fmt . Println ( t ) // Utgång: float64
}
I det här exemplet skapar vi en float64-variabel x med värdet 3,14. Vi anropar sedan reflect.TypeOf() för att få typen av x och lagrar resultatet i en reflect.Type-variabel t. Vi skriver ut värdet på t, som är float64.
reflect.ValueOf() Funktion
Reflect.ValueOf() kan få en reflect.Value-representation av ett värde. Det tar en enda parameter v, som kan vara vilket värde som helst av vilken typ som helst. Funktionen returnerar ett reflect.Value-värde som representerar värdet på indataparametern.
Användningen av reflect.ValueOf() kan demonstreras genom följande exempel:
paket huvudimportera (
'fmt'
'reflektera'
)
func huvud () {
var x flyta64 = 3 . 14
i := reflektera . Värdet av ( x )
fmt . Println ( i ) // Utgång: 3,14
}
I det här exemplet skapar vi en float64-variabel x med värdet 3,14. Vi anropar sedan reflect.ValueOf() för att få en reflektionsvärdesrepresentation av x och lagrar resultatet i en reflektionsvärdevariabel v. Vi skriver ut värdet på v, vilket är 3,14.
Reflektionspaketet innehåller många funktioner utöver de som nämns, och dessa är bara några exempel. Genom att använda funktionerna som tillhandahålls av reflect-paketet kan vi skapa kod som kan fungera med värden av vilken typ som helst, utan att behöva känna till typen vid kompileringstillfället.
Slutsats
Reflektion i Golang tillåter ett program att undersöka och ändra datastrukturer, typer och värden vid körning. Det implementeras genom reflekteringspaketet, som tillhandahåller funktioner för att inspektera och manipulera typer och värden. Reflektion är särskilt användbar när du arbetar med gränssnitt, okända typer eller när du behöver implementera generiska funktioner. Den här artikeln diskuterade grunderna för reflektion i Golang, inklusive reflektionspaketet, reflekterande typ och värde och dynamisk typ och värde.