Golang reflete

Bem -vindo a outro tutorial de Golang. Vamos aprender sobre a reflexão na linguagem de programação Go neste.

O que é reflexão?

Reflexão refere -se ao método de análise e inspeção de variáveis ​​e seus valores durante o tempo de execução. É uma técnica muito útil ao lidar com componentes abstratos de uma estrutura. Isso não significa que esteja limitado a estruturas. Vamos discutir vários componentes da reflexão em Golang.

Importações necessárias

Em Go, a capacidade de executar a reflexão é fornecida usando o pacote refletir. Portanto, precisamos importá -lo antes de usar. Você pode importá -lo como mostrado no trecho abaixo:

importar "refletir"

Uma vez importado, você pode começar a usar os métodos e funcionalidades fornecidos.

Tipo de()

Um método do pacote refletir é o tipo de (). Esta função permite determinar o tipo de variável.

Para usá -lo, podemos fazer:

Pacote principal
importação (
"FMT"
"Reflita"
)
func main ()
var1: = 100
var2: = 3.14159
var3: = "Olá"
var4: = […] int 1, 2, 3
var5: = map [string] string
var6: = verdadeiro
var7: = [] int 1, 2, 4
fmt.Println ("type =>", reflita.Typeof (var1))
fmt.Println ("type =>", reflita.Typeof (var2))
fmt.Println ("type =>", reflita.Typeof (var3))
fmt.Println ("type =>", reflita.Typeof (var4))
fmt.Println ("type =>", reflita.Typeof (var5))
fmt.Println ("type =>", reflita.Typeof (var6))
fmt.Println ("type =>", reflita.Typeof (var7))

O exemplo acima usa reflete.Método typeof () para verificar os tipos de dados de várias variáveis. A saída resultante é como mostrado:

Tipo => int
Tipo => float64
Tipo => string
Tipo => [3] int
Type => mapa [string] string
Tipo => bool
Tipo => [] int

Valor de()

O reflete.Método ValueOf () Retorna o valor de uma variável específica. Um exemplo é como mostrado:

fmt.Println ("value =>", reflita.Valorof (var4))

Isso deve retornar o valor da variável var4.

Saída:

Valor => [1 2 3]

Cópia de()

O método de cópia é usado para copiar os elementos de uma fonte específica para um destino especificado. A função executará a operação de cópia até que o destino esteja cheio dos elementos da fonte.

A função retorna o número de elementos copiados da fonte para o destino.

Lembre -se de que o destino e a fonte devem ser do mesmo tipo.

Considere o exemplo mostrado abaixo:

Pacote principal
importação (
"FMT"
"Reflita"
)
func main ()
src: = refletir.Valueof ([] string "A", "B", "C")
dest: = refletir.Valueof ([] string "d", "e", "f")
itens_copied: = refletir.Cópia (src, dest)
fmt.Println ("Elementos copiados:", itens_copied)
fmt.Println ("fonte:", src)
fmt.Println ("destino:", dest)

No exemplo acima, usamos o reflete.Valueof () lançar a variável para o seu tipo. Em seguida, usamos o método copy () para copiar os elementos do Dest para a variável SRC. A saída resultante é como mostrado:

Elementos copiados: 3
Fonte: [D E F]
Destino: [D E F]

Swapper ()

O método swapper () permite trocar elementos em uma fatia. Um exemplo é como mostrado abaixo:

lst: = [] int 1, 2, 3, 4, 5
lst_swp: = refletir.Swapper (LST)
fmt.Printf ("Antes da troca: %v \ n", LST)
lst_swp (0, 4)
fmt.Printf ("Após a troca: %v \ n", LST)

O exemplo acima troca a fatia do primeiro índice para o último. A saída é como mostrado:

Antes da troca: [1 2 3 4 5]
Após a troca: [5 2 3 4 1]

Numfield ()

O método Numfield () retorna o número de campos dentro de uma determinada estrutura. Um exemplo é como mostrado:

Digite my_struct struct
string field_1
campo_2 int
field_3 float64
campo_4 bool

struct_1: = my_struct "a", 1, 3.14, falso
elenco: = refletir.Typeof (struct_1)
fmt.Println (elenco.Numfield ())

O acima deve retornar o número de campos na estrutura. Saída:

4

Campo()

O método de campo () retorna o nome e o tipo de dados de campos dentro de uma estrutura.

struct_1: = my_struct "a", 1, 3.14, falso
elenco: = refletir.Typeof (struct_1)
para i: = 0; eu < cast.NumField(); i++
Campo: = fundido.Campo (i)
fmt.Println (campo.Nome, campo.Tipo)

O programa acima retorna o nome dos campos na estrutura e seus tipos de dados. Saída:

string field_1
campo_2 int
field_3 float64
campo_4 bool

Makechan ()

O método makechan () cria um canal de tamanho de tipo especificado e buffers de tamanho. Exemplo:

str str chan string
var str_type refletem.Valor = refletir.Valueof (& str)
new_channel: = refletir.Makechan (reflita.Indireto (str_type).Tipo (), 256)
fmt.Println ("tipo de canal:", new_channel.Tipo())
fmt.Println ("Cap de canal:", new_channel.Boné())

O acima deve criar um canal do tipo Chan e um tamanho de buffer de 256. A saída resultante é como mostrado:

Tipo de canal: chan
Capinha de canal: 256

Makemap ()

Como o nome sugere, a função makemap () cria um mapa do tipo de dados definido.

Veja o exemplo abaixo:

var str mapa [string] string
var str_type refletem.Valor = refletir.Valueof (& str)
my_map: = refletir.Makemap (reflita.Indireto (str_type).Tipo())
fmt.Println ("Kind =>", my_map.Tipo())

Isso cria um novo mapa. Saída:

Tipo => mapa

Conclusão

Neste guia, arranhamos a superfície de usar o pacote refletir em Go. Lembre -se de que o pacote oferece muito mais do que o que é discutido aqui.