A reflexão em Golang permite que um programa examine e modifique estruturas de dados, tipos e valores em tempo de execução. Ele fornece um conjunto de funções que nos permitem examinar o tipo e o valor de qualquer variável em tempo de execução, criar novas instâncias de tipos e modificar o valor das variáveis existentes. Este artigo cobre diferentes funções de Golang no pacote reflect.
Índice
- Refletir pacote em Go
- Função reflect.Copy()
- função reflect.DeepEqual()
- Função reflect.Swapper()
- Função reflect.TypeOf()
- Função reflect.ValueOf()
- Conclusão
Go é uma linguagem tipada estaticamente, então o tipo de uma variável deve ser conhecido em tempo de compilação. No entanto, em determinados cenários, pode ser necessário manipular valores cujos tipos não podem ser determinados até que o programa seja executado.
Por exemplo, podemos precisar escrever uma função que pode trabalhar com diferentes tipos de argumentos, ou podemos precisar serializar e desserializar dados de tipos desconhecidos. É aqui que o pacote reflect é usado em Golang.
Refletir pacote em Go
O pacote reflect fornece um conjunto de funções que nos permitem inspecionar e manipular valores em tempo de execução, independentemente de seus tipos. Com essas funções, podemos obter informações sobre o tipo e o valor de qualquer variável, criar novas instâncias de tipos e modificar o valor das variáveis existentes.
O pacote reflect em Golang contém dois tipos: Tipo e Valor. Um Type representa um tipo Go, como int, string ou uma struct personalizada. Um Value representa um valor de um tipo específico, como 42 ou “olá”.
O pacote reflect também fornece um conjunto de funções que nos permitem obter objetos Type e Value de variáveis. Por exemplo, a função reflect.TypeOf() retorna um objeto Type que representa o tipo de uma variável, enquanto a função reflect.ValueOf() fornece um objeto Value que mostra o valor da variável.
Nas seções a seguir, exploraremos algumas das funções comumente usadas no pacote reflect.
Função reflect.Copy()
A função reflect.Copy() do pacote reflect é usada para copiar os valores de uma fatia para outra fatia. Leva dois parâmetros, dst e src, ambos devem ser valores de fatia com o mesmo tipo de elemento. A função copia os valores da fatia src para a fatia dst e retorna o número de elementos que foram copiados.
A função reflect.Copy() é demonstrada no exemplo a seguir:
pacote principalimportar (
'fmt'
'refletir'
)
função principal () {
origem := [] int { 1 , 2 , 3 , 4 , 5 }
DST := fazer ([] int , apenas ( origem ))
n := refletir . cópia de ( refletir . Valor de ( DST ), refletir . Valor de ( origem ))
fmt . Println ( n ) // Saída: 5
fmt . Println ( DST ) // Saída: [1 2 3 4 5]
}
Neste exemplo, criamos uma fatia de origem src com alguns valores inteiros e uma fatia de destino dst com o mesmo comprimento de src. Em seguida, chamamos reflect.Copy() para copiar os valores de src para dst e imprimir o número de elementos que foram copiados (n) e o conteúdo da fatia dst.
função reflect.DeepEqual()
A função reflect.DeepEqual() do pacote reflect é usada para comparar dois valores de igualdade. Esta função tem dois parâmetros de entrada que são a e b, sendo que ambos podem ser de qualquer valor de qualquer tipo. A função retorna true se a e b forem profundamente iguais, o que significa que seus valores subjacentes são recursivamente iguais. Caso contrário, acaba sendo falso.
O exemplo a seguir mostra como usar reflect.DeepEqual():
pacote principalimportar (
'fmt'
'refletir'
)
função principal () {
a := [] int { 1 , 2 , 3 }
b := [] int { 1 , 2 , 3 }
se refletir . DeepEqual ( a , b ) {
fmt . Println ( 'a e b são iguais' )
} outro {
fmt . Println ( 'a e b não são iguais' )
}
}
Neste exemplo, criamos duas fatias a e b com os mesmos valores inteiros. Em seguida, chamamos reflect.DeepEqual() para comparar aeb para igualdade e imprimir o resultado.
Função reflect.Swapper()
A função reflect.Swapper() do pacote reflect é usada para retornar uma função que pode trocar os elementos de uma fatia. Leva um único parâmetro, v, que deve ser um valor de fatia. A função retorna uma função que recebe dois parâmetros inteiros, i e j, e troca os elementos da fatia nas posições i e j.
O uso de reflect.Swapper() pode ser demonstrado através do seguinte exemplo:
pacote principalimportar (
'fmt'
'refletir'
)
função principal () {
s := [] int { 1 , 2 , 3 , 4 , 5 }
trocar := refletir . trocador ( s )
trocar ( 1 , 3 )
fmt . Println ( s ) // Saída: [1 4 3 2 5]
}
Neste exemplo, criamos uma fatia chamada s com alguns valores inteiros. Em seguida, chamamos reflect.Swapper() para obter uma troca de função que pode trocar elementos da fatia. Usamos swap para trocar os elementos nas posições 1 e 3 da fatia s e imprimir o resultado.
Função reflect.TypeOf()
O reflect.TypeOf() é usado para obter o tipo de um valor. Esta função aceita um único parâmetro “v” que pode ser de qualquer tipo ou valor. A função retorna um valor reflect.Type que representa o tipo do valor.
O uso de reflect.TypeOf() pode ser demonstrado através do seguinte exemplo:
pacote principalimportar (
'fmt'
'refletir'
)
função principal () {
era x float64 = 3 . 14
t := refletir . Tipo de ( x )
fmt . Println ( t ) // Saída: float64
}
Neste exemplo, criamos uma variável float64 x com o valor 3,14. Em seguida, chamamos reflect.TypeOf() para obter o tipo de x e armazenar o resultado em uma variável reflect.Type t. Imprimimos o valor de t, que é float64.
Função reflect.ValueOf()
O reflect.ValueOf() pode obter uma representação reflect.Value de um valor. Leva um único parâmetro v, que pode ser qualquer valor de qualquer tipo. A função retorna um valor reflect.Value que representa o valor do parâmetro de entrada.
O uso de reflect.ValueOf() pode ser demonstrado através do seguinte exemplo:
pacote principalimportar (
'fmt'
'refletir'
)
função principal () {
era x float64 = 3 . 14
em := refletir . Valor de ( x )
fmt . Println ( em ) // Saída: 3.14
}
Neste exemplo, criamos uma variável float64 x com o valor 3,14. Em seguida, chamamos reflect.ValueOf() para obter uma representação do valor de reflexão de x e armazenar o resultado em uma variável de valor de reflexão v. Imprimimos o valor de v, que é 3,14.
O pacote reflect fornece inúmeras funções além das mencionadas, e estes são apenas alguns exemplos. Usando as funções fornecidas pelo pacote reflect, podemos criar código que pode trabalhar com valores de qualquer tipo, sem a necessidade de saber o tipo no momento da compilação.
Conclusão
A reflexão em Golang permite que um programa examine e modifique estruturas de dados, tipos e valores em tempo de execução. Ele é implementado por meio do pacote reflect, que fornece funções para inspecionar e manipular tipos e valores. A reflexão é especialmente útil ao trabalhar com interfaces, tipos desconhecidos ou quando você precisa implementar funções genéricas. Este artigo discutiu os fundamentos da reflexão em Golang, incluindo o pacote reflect, reflect Type and Value e dynamic type and value.