Golang riflette

Benvenuti in un altro tutorial Golang. Impareremo a riflettere nel linguaggio di programmazione Go in questo.

Cos'è la riflessione?

La riflessione si riferisce al metodo di analisi e ispezione delle variabili e dei loro valori durante il runtime. È una tecnica molto utile quando si tratta di componenti astratti di una struttura. Ciò non significa che sia limitato alle strutture. Discutiamo di vari componenti della riflessione in Golang.

Importazioni richieste

In Go, la capacità di eseguire la riflessione è fornita utilizzando il pacchetto Reflect. Quindi, dobbiamo importarlo prima dell'uso. È possibile importarlo come mostrato nello snippet di seguito:

Importa "Rifletti"

Una volta importato, è possibile iniziare a utilizzare i metodi e le funzionalità fornite.

Tipo di()

Un metodo dal pacchetto Reflect è il typeof (). Questa funzione consente di determinare il tipo di variabile.

Per usarlo, possiamo fare:

Pacchetto principale
importazione (
"FMT"
"riflettere"
)
func main ()
var1: = 100
var2: = 3.14159
var3: = "ciao"
var4: = […] int 1, 2, 3
var5: = map [string] string
var6: = true
var7: = [] int 1, 2, 4
fmt.Println ("type =>", riflette.Typeof (var1))
fmt.Println ("type =>", riflette.Typeof (var2))
fmt.Println ("type =>", riflette.Typeof (var3))
fmt.Println ("type =>", riflette.Typeof (var4))
fmt.Println ("type =>", riflette.Typeof (var5))
fmt.Println ("type =>", riflette.Typeof (var6))
fmt.Println ("type =>", riflette.Typeof (var7))

L'esempio sopra usa si riflette.Metodo typeof () per verificare i tipi di dati di varie variabili. L'output risultante è come mostrato:

Tipo => int
Tipo => float64
Tipo => stringa
Type => [3] int
Type => map [string] stringa
Tipo => bool
Type => [] int

Valore di()

Il riflesso.Il metodo valueof () restituisce il valore di una variabile specifica. Un esempio è come mostrato:

fmt.Println ("value =>", riflette.Valore di (var4))

Questo dovrebbe restituire il valore della variabile VAR4.

Produzione:

Valore => [1 2 3]

Copia()

Il metodo di copia viene utilizzato per copiare gli elementi di una fonte specifica in una destinazione specificata. La funzione eseguirà l'operazione di copia fino a quando la destinazione è piena degli elementi dalla fonte.

La funzione restituisce il numero di elementi copiati dall'origine alla destinazione.

Ricorda che la destinazione e l'origine devono essere dello stesso tipo.

Considera l'esempio mostrato di seguito:

Pacchetto principale
importazione (
"FMT"
"riflettere"
)
func main ()
src: = riflette.Valueof ([] string "a", "b", "c")
dest: = riflette.Valowof ([] string "d", "e", "f")
elementi_copied: = riflette.Copia (SRC, dest)
fmt.Println ("elementi copiati:", elementi_copied)
fmt.Println ("fonte:", src)
fmt.Println ("destinazione:", dest)

Nell'esempio sopra, usiamo il riflesso.Valowof () per lanciare la variabile al suo tipo. Quindi utilizziamo il metodo COPY () per copiare gli elementi della DEST nella variabile SRC. L'output risultante è come mostrato:

Elementi copiati: 3
Fonte: [d e f]
Destinazione: [d e f]

Swapper ()

Il metodo Swapper () consente di scambiare elementi in una fetta. Un esempio è come mostrato di seguito:

lst: = [] int 1, 2, 3, 4, 5
lst_swp: = riflette.Swapper (LST)
fmt.Printf ("prima dello scambio: %v \ n", LST)
LST_SWP (0, 4)
fmt.Printf ("Dopo lo scambio: %v \ n", LST)

L'esempio sopra scambia la fetta dal primo indice all'ultimo. L'output è come mostrato:

Prima dello scambio: [1 2 3 4 5]
Dopo lo scambio: [5 2 3 4 1]

Numfield ()

Il metodo Numfield () restituisce il numero di campi all'interno di una determinata struttura. Un esempio è come mostrato:

Digita my_struct struct
Field_1 String
field_2 int
Field_3 Float64
field_4 bool

struct_1: = my_struct "a", 1, 3.14, false
Cast: = Rifletti.Typeof (struct_1)
fmt.Println (cast.Numfield ())

Quanto sopra dovrebbe restituire il numero di campi nella struttura. Produzione:

4

Campo()

Il metodo field () restituisce il nome e il tipo di dati dei campi all'interno di una struttura.

struct_1: = my_struct "a", 1, 3.14, false
Cast: = Rifletti.Typeof (struct_1)
per i: = 0; io < cast.NumField(); i++
campo: = cast.Campo (i)
fmt.Println (campo.Nome, campo.Tipo)

Il programma di cui sopra restituisce il nome dei campi nella struttura e nei loro tipi di dati. Produzione:

Field_1 String
field_2 int
Field_3 Float64
field_4 bool

Makechan ()

Il metodo Makechan () crea un canale di tipo e tamponi specificati. Esempio:

Var Str Chan String
var str_type riflette.Value = riflette.Valoreof (& STR)
new_channel: = riflette.Makechan (riflette.Indiretto (str_type).Tipo (), 256)
fmt.Println ("Kinding Kind:", New_Channel.Tipo())
fmt.Println ("Cap del canale:", New_Channel.Cap ())

Quanto sopra dovrebbe creare un canale di tipo Chan e una dimensione del buffer di 256. L'output risultante è come mostrato:

Tipo di canale: Chan
Cap del canale: 256

Makemap ()

Come suggerisce il nome, la funzione makemap () crea una mappa del tipo di dati definito.

Prendi l'esempio di seguito:

Var Str MAP [String] String
var str_type riflette.Value = riflette.Valoreof (& STR)
my_map: = riflette.Makemap (riflette.Indiretto (str_type).Tipo())
fmt.Println ("kind =>", my_map.Tipo())

Questo crea una nuova mappa. Produzione:

Tipo => mappa

Conclusione

In questa guida, abbiamo graffiato la superficie dell'utilizzo del pacchetto di riflesso in Go. Tieni presente che il pacchetto offre molto più di quello che viene discusso qui.