Ce este Reflecția în Golang

Ce Este Reflectia In Golang



Reflection în Golang permite unui program să examineze și să modifice structurile, tipurile și valorile de date în timpul execuției. Oferă un set de funcții care ne permit să examinăm tipul și valoarea oricărei variabile în timpul execuției, să creăm noi instanțe de tipuri și să modificăm valoarea variabilelor existente. Acest articol acoperă diferite funcții Golang din pachetul reflect.

Cuprins

Go este un limbaj tipizat static, astfel încât tipul unei variabile trebuie să fie cunoscut în momentul compilării. Cu toate acestea, în anumite scenarii, poate fi necesar să se gestioneze valori ale căror tipuri nu pot fi determinate până când programul este executat.







De exemplu, poate fi nevoie să scriem o funcție care poate funcționa cu diferite tipuri de argumente sau poate fi nevoie să serializeze și să deserializeze date de tipuri necunoscute. Aici este folosit pachetul reflect în Golang.



Pachetul Reflect în Go

Pachetul reflect oferă un set de funcții care ne permit să inspectăm și să manipulăm valorile în timpul execuției, indiferent de tipurile acestora. Cu aceste funcții, putem obține informații despre tipul și valoarea oricărei variabile, putem crea instanțe noi de tipuri și putem modifica valoarea variabilelor existente.



Pachetul reflect în Golang conține două tipuri: Tip și valoare. Un Type reprezintă un tip Go, cum ar fi int, șir sau o structură personalizată. O valoare reprezintă o valoare de un anumit tip, cum ar fi 42 sau „bună ziua”.





Pachetul reflect oferă, de asemenea, un set de funcții care ne permit să obținem obiecte Type și Value din variabile. De exemplu, funcția reflect.TypeOf() returnează un obiect Type care reprezintă tipul unei variabile, în timp ce funcția reflect.ValueOf() oferă un obiect Value care arată valoarea variabilei.

În secțiunile următoare, vom explora câteva dintre funcțiile utilizate frecvent în pachetul reflect.



reflect.Copy() Funcția

Funcția reflect.Copy() a pachetului reflect este folosită pentru a copia valorile unei felii într-o altă felie. Este nevoie de doi parametri, dst și src, ambii trebuie să fie valori ale secțiunii cu același tip de element. Funcția copiază valorile din porțiunea src în porțiunea dst și returnează numărul de elemente care au fost copiate.

Funcția reflect.Copy() este demonstrată în următorul exemplu:

pachet principal

import (

'fmt'
'Reflectați'
)
func principal () {
src := [] int { 1 , 2 , 3 , 4 , 5 }
dst := face ([] int , numai ( src ))
n := Reflectați . Copie ( Reflectați . Valoarea ( dst ), Reflectați . Valoarea ( src ))
fmt . Println ( n ) // Ieșire: 5
fmt . Println ( dst ) // Ieșire: [1 2 3 4 5]


}

În acest exemplu, creăm o porțiune sursă src cu niște valori întregi și o porțiune destinație dst cu aceeași lungime ca și src. Apoi apelăm reflect.Copy() pentru a copia valorile din src în dst și a tipări numărul de elemente care au fost copiate (n) și conținutul secțiunii dst.

reflect.DeepEqual() Funcția

Funcția reflect.DeepEqual() a pachetului reflect este utilizată pentru a compara două valori pentru egalitate. Această funcție are doi parametri de intrare care sunt a și b, ambii putând avea orice valoare de orice tip. Funcția returnează adevărat dacă a și b sunt profund egale, ceea ce înseamnă că valorile lor subiacente sunt egale recursiv. Altfel, se dovedește a fi fals.

Următorul exemplu arată cum să utilizați reflect.DeepEqual():

pachet principal

import (

'fmt'
'Reflectați'
)
func principal () {
A := [] int { 1 , 2 , 3 }
b := [] int { 1 , 2 , 3 }
dacă Reflectați . DeepEqual ( A , b ) {
fmt . Println ( „a și b sunt egale” )
} altfel {
fmt . Println ( „a și b nu sunt egale” )
}


}

În acest exemplu, creăm două felii a și b cu aceleași valori întregi. Apoi apelăm reflect.DeepEqual() pentru a compara a și b pentru egalitate și pentru a imprima rezultatul.

reflect.Swapper() Funcția

Funcția reflect.Swapper() a pachetului reflect este folosită pentru a returna o funcție care poate schimba elementele unei felii. Este nevoie de un singur parametru, v, care trebuie să fie o valoare de felie. Funcția returnează o funcție care ia doi parametri întregi, i și j, și schimbă elementele feliei la pozițiile i și j.

Utilizarea reflect.Swapper() poate fi demonstrată prin următorul exemplu:

pachet principal

import (

'fmt'
'Reflectați'
)
func principal () {
s := [] int { 1 , 2 , 3 , 4 , 5 }
schimb := Reflectați . Schimbător ( s )
schimb ( 1 , 3 )
fmt . Println ( s ) // Ieșire: [1 4 3 2 5]


}

În acest exemplu, am creat o porțiune numită s cu niște valori întregi. Apoi apelăm reflect.Swapper() pentru a obține o funcție swap care poate schimba elemente ale feliei. Folosim swap pentru a schimba elementele din pozițiile 1 și 3 ale feliei s și tipărim rezultatul.

reflect.TypeOf() Funcția

Reflect.TypeOf() este folosit pentru a obține tipul unei valori. Această funcție acceptă un singur parametru „v” care poate fi de orice tip sau valoare. Funcția returnează o valoare reflect.Type care reprezintă tipul valorii.

Utilizarea reflect.TypeOf() poate fi demonstrată prin următorul exemplu:

pachet principal

import (

'fmt'
'Reflectați'
)
func principal () {
a fost X float64 = 3 . 14
t := Reflectați . Tip de ( X )
fmt . Println ( t ) // Ieșire: float64


}

În acest exemplu, creăm o variabilă float64 x cu valoarea 3.14. Apoi apelăm reflect.TypeOf() pentru a obține tipul de x și stoca rezultatul într-o variabilă reflect.Type t. Tipărim valoarea lui t, care este float64.

reflect.ValueOf() Funcția

Reflect.ValueOf() poate obține o reprezentare reflect.Value a unei valori. Este nevoie de un singur parametru v, care poate fi orice valoare de orice tip. Funcția returnează o valoare reflect.Value care reprezintă valoarea parametrului de intrare.

Utilizarea reflect.ValueOf() poate fi demonstrată prin următorul exemplu:

pachet principal

import (

'fmt'
'Reflectați'
)
func principal () {
a fost X float64 = 3 . 14
în := Reflectați . Valoarea ( X )
fmt . Println ( în ) // Ieșire: 3.14

}

În acest exemplu, creăm o variabilă float64 x cu valoarea 3.14. Apoi apelăm reflect.ValueOf() pentru a obține o reprezentare reflect-value a lui x și stocăm rezultatul într-o variabilă reflect-value v. Imprimăm valoarea lui v, care este 3,14.

Pachetul reflect oferă numeroase funcții dincolo de cele menționate, iar acestea sunt doar câteva exemple. Folosind funcțiile oferite de pachetul reflect, putem crea cod care poate funcționa cu valori de orice tip, fără a fi nevoie să cunoaștem tipul în momentul compilării.

Concluzie

Reflection în Golang permite unui program să examineze și să modifice structurile, tipurile și valorile de date în timpul execuției. Este implementat prin pachetul reflect, care oferă funcții pentru inspectarea și manipularea tipurilor și valorilor. Reflection este utilă în special atunci când lucrați cu interfețe, tipuri necunoscute sau când trebuie să implementați funcții generice. Acest articol a discutat elementele de bază ale reflectării în Golang, inclusiv pachetul reflect, reflect Type and Value, precum și tipul dinamic și valoarea.