Reflectie in Golang stelt een programma in staat om datastructuren, typen en waarden tijdens runtime te onderzoeken en aan te passen. Het biedt een reeks functies waarmee we het type en de waarde van elke variabele tijdens runtime kunnen onderzoeken, nieuwe instanties van typen kunnen maken en de waarde van bestaande variabelen kunnen wijzigen. Dit artikel behandelt verschillende Golang-functies in het reflect-pakket.
Inhoudsopgave
- Reflecteer pakket in Go
- reflect.Copy() Functie
- reflect.DeepEqual() Functie
- reflect.Swapper() Functie
- reflect.TypeOf() Functie
- reflect.ValueOf() Functie
- Conclusie
Go is een statisch getypeerde taal, dus het type van een variabele moet tijdens het compileren bekend zijn. In bepaalde scenario's kan het echter nodig zijn om waarden te hanteren waarvan de typen pas kunnen worden bepaald als het programma wordt uitgevoerd.
Het kan bijvoorbeeld zijn dat we een functie moeten schrijven die met verschillende typen argumenten kan werken, of dat we gegevens van onbekende typen moeten serialiseren en deserialiseren. Dit is waar het reflectiepakket in Golang wordt gebruikt.
Reflecteer pakket in Go
Het reflect-pakket biedt een reeks functies waarmee we waarden tijdens runtime kunnen inspecteren en manipuleren, ongeacht hun type. Met deze functies kunnen we informatie verkrijgen over het type en de waarde van elke variabele, nieuwe exemplaren van typen maken en de waarde van bestaande variabelen wijzigen.
Het reflectiepakket in Golang bevat twee soorten: Type en waarde. Een type vertegenwoordigt een Go-type, zoals int, string of een aangepaste structuur. Een waarde vertegenwoordigt een waarde van een specifiek type, zoals 42 of 'hallo'.
Het reflect-pakket biedt ook een reeks functies waarmee we Type- en Value-objecten uit variabelen kunnen verkrijgen. De functie reflect.TypeOf() retourneert bijvoorbeeld een object Type dat het type van een variabele vertegenwoordigt, terwijl de functie reflect.ValueOf() een object Value geeft dat de variabelewaarde weergeeft.
In de volgende secties zullen we enkele veelgebruikte functies in het reflect-pakket onderzoeken.
reflect.Copy() Functie
De functie reflect.Copy() van het reflect-pakket wordt gebruikt om de waarden van een segment naar een ander segment te kopiëren. Er zijn twee parameters nodig, dst en src, die beide segmentwaarden moeten zijn met hetzelfde elementtype. De functie kopieert de waarden van de src-slice naar de dst-slice en retourneert het aantal elementen dat is gekopieerd.
De functie reflect.Copy() wordt gedemonstreerd in het volgende voorbeeld:
pakket voornaamstimporteren (
'fmt'
'reflecteren'
)
func voornaamst () {
src := [] int { 1 , 2 , 3 , 4 , 5 }
dst := maken ([] int , alleen ( src ))
N := weerspiegelen . Kopiëren ( weerspiegelen . Waarde van ( dst ), weerspiegelen . Waarde van ( src ))
fmt . Println ( N ) // Uitvoer: 5
fmt . Println ( dst ) // Uitvoer: [1 2 3 4 5]
}
In dit voorbeeld maken we een bronsegment src met enkele gehele waarden en een bestemmingssegment dst met dezelfde lengte als src. Vervolgens roepen we reflect.Copy() aan om de waarden van src naar dst te kopiëren en het aantal gekopieerde elementen (n) en de inhoud van het dst-segment af te drukken.
reflect.DeepEqual() Functie
De functie reflect.DeepEqual() van het reflect-pakket wordt gebruikt om twee waarden voor gelijkheid te vergelijken. Deze functie heeft twee invoerparameters, a en b, die beide elke waarde van elk type kunnen hebben. De functie retourneert true als a en b diep gelijk zijn, wat betekent dat hun onderliggende waarden recursief gelijk zijn. Anders blijkt het vals te zijn.
Het volgende voorbeeld laat zien hoe reflect.DeepEqual() gebruikt wordt:
pakket voornaamstimporteren (
'fmt'
'reflecteren'
)
func voornaamst () {
A := [] int { 1 , 2 , 3 }
B := [] int { 1 , 2 , 3 }
als weerspiegelen . DeepEqual ( A , B ) {
fmt . Println ( 'a en b zijn gelijk' )
} anders {
fmt . Println ( 'a en b zijn niet gelijk' )
}
}
In dit voorbeeld maken we twee segmenten a en b met dezelfde integerwaarden. Vervolgens roepen we reflect.DeepEqual() aan om a en b te vergelijken voor gelijkheid en het resultaat af te drukken.
reflect.Swapper() Functie
De functie reflect.Swapper() van het reflect-pakket wordt gebruikt om een functie te retourneren die de elementen van een segment kan verwisselen. Er is een enkele parameter voor nodig, v, die een segmentwaarde moet zijn. De functie retourneert een functie waaraan twee integer-parameters, i en j, moeten doorgegeven worden en de elementen van de slice op de posities i en j worden verwisseld.
Het gebruik van reflect.Swapper() kan worden gedemonstreerd aan de hand van het volgende voorbeeld:
pakket voornaamstimporteren (
'fmt'
'reflecteren'
)
func voornaamst () {
S := [] int { 1 , 2 , 3 , 4 , 5 }
ruil := weerspiegelen . Wisselaar ( S )
ruil ( 1 , 3 )
fmt . Println ( S ) // Uitvoer: [1 4 3 2 5]
}
In dit voorbeeld hebben we een segment met de naam s gemaakt met enkele gehele waarden. Vervolgens roepen we reflect.Swapper() aan om een functie swap te verkrijgen die elementen van de slice kan verwisselen. We gebruiken swap om de elementen op positie 1 en 3 van de s-slice om te wisselen en het resultaat af te drukken.
reflect.TypeOf() Functie
De reflect.TypeOf() wordt gebruikt om het type van een waarde te krijgen. Deze functie accepteert een enkele parameter 'v' die van elk type of waarde kan zijn. De functie retourneert een reflect.Type-waarde die het type waarde vertegenwoordigt.
Het gebruik van reflect.TypeOf() kan worden gedemonstreerd aan de hand van het volgende voorbeeld:
pakket voornaamstimporteren (
'fmt'
'reflecteren'
)
func voornaamst () {
was X vlotter64 = 3 . 14
T := weerspiegelen . Soort van ( X )
fmt . Println ( T ) // Uitvoer: float64
}
In dit voorbeeld maken we een variabele float64 x met de waarde 3.14. We roepen dan reflect.TypeOf() aan om het type x te krijgen en slaan het resultaat op in een reflect.Type variabele t. We printen de waarde van t, dat is float64.
reflect.ValueOf() Functie
De reflect.ValueOf() kan een reflect.Value-representatie van een waarde krijgen. Er is een enkele parameter v voor nodig, die elke waarde van elk type kan zijn. De functie retourneert een reflect.Value-waarde die de waarde van de invoerparameter vertegenwoordigt.
Het gebruik van reflect.ValueOf() kan worden gedemonstreerd aan de hand van het volgende voorbeeld:
pakket voornaamstimporteren (
'fmt'
'reflecteren'
)
func voornaamst () {
was X vlotter64 = 3 . 14
in := weerspiegelen . Waarde van ( X )
fmt . Println ( in ) // Uitvoer: 3.14
}
In dit voorbeeld maken we een variabele float64 x met de waarde 3.14. Vervolgens roepen we reflect.ValueOf() aan om een reflect-waarde-representatie van x te krijgen en het resultaat op te slaan in een reflect-value-variabele v. We printen de waarde van v, die 3,14 is.
Het reflect-pakket biedt tal van functies buiten de genoemde, en dit zijn slechts enkele voorbeelden. Door de functies van het reflect-pakket te gebruiken, kunnen we code maken die met waarden van elk type kan werken, zonder dat we het type bij het compileren hoeven te weten.
Conclusie
Reflectie in Golang stelt een programma in staat om datastructuren, typen en waarden tijdens runtime te onderzoeken en aan te passen. Het wordt geïmplementeerd via het reflect-pakket, dat functies biedt voor het inspecteren en manipuleren van typen en waarden. Reflectie is vooral handig bij het werken met interfaces, onbekende typen of wanneer u generieke functies moet implementeren. Dit artikel besprak de basisprincipes van reflectie in Golang, inclusief het reflect-pakket, reflect Type and Value, en dynamic type and value.