La riflessione in Golang consente a un programma di esaminare e modificare strutture dati, tipi e valori in fase di esecuzione. Fornisce un insieme di funzioni che ci consentono di esaminare il tipo e il valore di qualsiasi variabile in fase di esecuzione, creare nuove istanze di tipi e modificare il valore delle variabili esistenti. Questo articolo copre diverse funzioni Golang nel pacchetto reflect.
Sommario
- Rifletti il pacchetto in Go
- Funzione reflect.Copy()
- Funzione reflect.DeepEqual()
- Funzione reflect.Swapper()
- Funzione reflect.TypeOf()
- Funzione reflect.ValueOf()
- Conclusione
Go è un linguaggio tipizzato staticamente, quindi il tipo di una variabile deve essere noto in fase di compilazione. Tuttavia, in alcuni scenari, potrebbe essere necessario gestire valori i cui tipi non possono essere determinati finché il programma non viene eseguito.
Ad esempio, potrebbe essere necessario scrivere una funzione in grado di funzionare con diversi tipi di argomenti oppure potrebbe essere necessario serializzare e deserializzare dati di tipi sconosciuti. Qui è dove viene utilizzato il pacchetto reflect in Golang.
Rifletti il pacchetto in Go
Il pacchetto reflect fornisce un insieme di funzioni che ci consentono di ispezionare e manipolare i valori in fase di esecuzione, indipendentemente dal loro tipo. Con queste funzioni possiamo ottenere informazioni sul tipo e sul valore di qualsiasi variabile, creare nuove istanze di tipi e modificare il valore delle variabili esistenti.
Il pacchetto reflect in Golang contiene due tipi: Tipo e Valore. Un Type rappresenta un tipo Go, ad esempio int, string o uno struct personalizzato. Un valore rappresenta un valore di un tipo specifico, ad esempio 42 o 'ciao'.
Il pacchetto reflect fornisce anche un insieme di funzioni che ci permettono di ottenere oggetti Type e Value dalle variabili. Ad esempio, la funzione reflect.TypeOf() restituisce un oggetto Type che rappresenta il tipo di una variabile, mentre la funzione reflect.ValueOf() restituisce un oggetto Value che mostra il valore della variabile.
Nelle sezioni seguenti, esploreremo alcune delle funzioni comunemente usate nel pacchetto reflect.
Funzione reflect.Copy()
La funzione reflect.Copy() del pacchetto reflect viene utilizzata per copiare i valori di una sezione in un'altra sezione. Accetta due parametri, dst e src, entrambi devono essere valori di slice con lo stesso tipo di elemento. La funzione copia i valori dalla sezione src nella sezione dst e restituisce il numero di elementi che sono stati copiati.
La funzione reflect.Copy() è illustrata nel seguente esempio:
pacchetto principaleimportare (
'fmt'
'riflettere'
)
funz principale () {
src := [] int { 1 , 2 , 3 , 4 , 5 }
dst := Fare ([] int , soltanto ( src ))
N := riflettere . copia ( riflettere . Valore di ( dst ), riflettere . Valore di ( src ))
fmt . Stampaln ( N ) // Uscita: 5
fmt . Stampaln ( dst ) // Uscita: [1 2 3 4 5]
}
In questo esempio, creiamo una slice di origine src con alcuni valori interi e una slice di destinazione dst con la stessa lunghezza di src. Quindi chiamiamo reflect.Copy() per copiare i valori da src a dst e stampare il numero di elementi che sono stati copiati (n) e il contenuto della sezione dst.
Funzione reflect.DeepEqual()
La funzione reflect.DeepEqual() del pacchetto reflect viene utilizzata per confrontare due valori per verificarne l'uguaglianza. Questa funzione ha due parametri di input che sono a e b, entrambi possono avere qualsiasi valore di qualsiasi tipo. La funzione restituisce true se a e b sono profondamente uguali, il che significa che i loro valori sottostanti sono ricorsivamente uguali. Altrimenti, risulta essere falso.
L'esempio seguente mostra come utilizzare reflect.DeepEqual():
pacchetto principaleimportare (
'fmt'
'riflettere'
)
funz principale () {
UN := [] int { 1 , 2 , 3 }
B := [] int { 1 , 2 , 3 }
Se riflettere . DeepEqual ( UN , B ) {
fmt . Stampaln ( 'a e b sono uguali' )
} altro {
fmt . Stampaln ( 'a e b non sono uguali' )
}
}
In questo esempio creiamo due fette a e b con gli stessi valori interi. Quindi chiamiamo reflect.DeepEqual() per confrontare a e b per l'uguaglianza e stampare il risultato.
Funzione reflect.Swapper()
La funzione reflect.Swapper() del pacchetto reflect viene utilizzata per restituire una funzione che può scambiare gli elementi di una slice. Accetta un singolo parametro, v, che deve essere un valore di fetta. La funzione restituisce una funzione che accetta due parametri interi, i e j, e scambia gli elementi della fetta nelle posizioni i e j.
L'utilizzo di reflect.Swapper() può essere dimostrato tramite il seguente esempio:
pacchetto principaleimportare (
'fmt'
'riflettere'
)
funz principale () {
S := [] int { 1 , 2 , 3 , 4 , 5 }
scambio := riflettere . Scambiatore ( S )
scambio ( 1 , 3 )
fmt . Stampaln ( S ) // Uscita: [1 4 3 2 5]
}
In questo esempio, abbiamo creato una sezione denominata s con alcuni valori interi. Quindi chiamiamo reflect.Swapper() per ottenere una funzione swap che può scambiare gli elementi della slice. Usiamo swap per scambiare gli elementi nelle posizioni 1 e 3 della sezione s e stampare il risultato.
Funzione reflect.TypeOf()
Il reflect.TypeOf() viene utilizzato per ottenere il tipo di un valore. Questa funzione accetta un singolo parametro “v” che può essere di qualsiasi tipo o valore. La funzione restituisce un valore reflect.Type che rappresenta il tipo del valore.
L'utilizzo di reflect.TypeOf() può essere dimostrato attraverso il seguente esempio:
pacchetto principaleimportare (
'fmt'
'riflettere'
)
funz principale () {
era X galleggiante64 = 3 . 14
T := riflettere . Tipo di ( X )
fmt . Stampaln ( T ) // Uscita: float64
}
In questo esempio, creiamo una variabile float64 x con il valore 3.14. Quindi chiamiamo reflect.TypeOf() per ottenere il tipo di x e memorizzare il risultato in una variabile reflect.Type t. Stampiamo il valore di t, che è float64.
Funzione reflect.ValueOf()
Il reflect.ValueOf() può ottenere una rappresentazione reflect.Value di un valore. Prende un singolo parametro v, che può essere qualsiasi valore di qualsiasi tipo. La funzione restituisce un valore reflect.Value che rappresenta il valore del parametro di input.
L'utilizzo di reflect.ValueOf() può essere dimostrato attraverso il seguente esempio:
pacchetto principaleimportare (
'fmt'
'riflettere'
)
funz principale () {
era X galleggiante64 = 3 . 14
In := riflettere . Valore di ( X )
fmt . Stampaln ( In ) // Uscita: 3.14
}
In questo esempio, creiamo una variabile float64 x con il valore 3.14. Quindi chiamiamo reflect.ValueOf() per ottenere una rappresentazione del valore di riflessione di x e memorizziamo il risultato in una variabile di valore di riflessione v. Stampiamo il valore di v, che è 3.14.
Il pacchetto reflect fornisce numerose funzioni oltre a quelle citate, e questi sono solo alcuni esempi. Utilizzando le funzioni fornite dal pacchetto reflect, possiamo creare codice in grado di lavorare con valori di qualsiasi tipo, senza bisogno di conoscere il tipo al momento della compilazione.
Conclusione
La riflessione in Golang consente a un programma di esaminare e modificare strutture dati, tipi e valori in fase di esecuzione. È implementato tramite il pacchetto reflect, che fornisce funzioni per ispezionare e manipolare tipi e valori. La riflessione è particolarmente utile quando si lavora con interfacce, tipi sconosciuti o quando è necessario implementare funzioni generiche. Questo articolo ha discusso le basi della reflection in Golang, inclusi il pacchetto reflect, il tipo e il valore di reflect e il tipo e il valore dinamici.