¿Cómo encontrar el tipo de Struct en Golang?

Una estructura o estructura en Golang es un tipo de datos definido por el usuario que es una composición de varios campos de datos. Cada campo de datos tiene su propio tipo de datos, que puede ser un tipo integrado o definido por el usuario. Struct representa cualquier entidad del mundo real que tenga algún conjunto de propiedades/campos. Go no admite el concepto de clases, las estructuras son la única forma de crear un tipo definido por el usuario en este lenguaje. Hay varias formas en las que podemos identificar el tipo de estructura en Go:

Método 1: usar el paquete de reflejo

Puede usar el paquete reflect para encontrar el tipo dado de una estructura. El paquete Reflection permite determinar el tipo de variables en tiempo de ejecución.

Sintaxis:

func typeofstruct(x interface{}){
    fmt.Println(reflect.TypeOf(x))
}

o

func typeofstruct(x interface{}){
    fmt.Println(reflect.ValueOf(x).Kind())
}

Ejemplo:

package main
  
// importing required modules
import (
    "fmt"
    "reflect"
)
  
//struct Student definition
type Student struct {
    name   string
    rollno int
    phone  int64
    city   string
}
  
func main() {
  
    // making a struct instance
    // note: data fields should be entered in the order
    // they are declared in the struct definition
    var st1 = Student{"Raman", 01, 88888888888, "Mumbai"}
    fmt.Println(reflect.TypeOf(st1))
    fmt.Println(reflect.ValueOf(st1).Kind())
  
    // Naming fields while
    // initializing a struct
    st2 := Student{name: "Naman", rollno: 02, 
            phone: 1010101010, city: "Delhi"}
    fmt.Println(reflect.TypeOf(st2))
    fmt.Println(reflect.ValueOf(st2).Kind())
}

Producción:

main.Student
struct
main.Student
struct

El método reflect.TypeOf devuelve el tipo main.Student mientras que el método reflect.Kind devuelve una estructura. Es porque el método reflect.TypeOf devuelve una variable de tipo reflect.Type . reflect.Type contiene toda la información sobre el tipo que define la variable que se pasó, en este caso, Student. El tipo dice de qué está hecho inicialmente este tipo: un puntero, un int, una string, una estructura, una interfaz u otro tipo de datos incorporado. En nuestro caso, el tipo es un estudiante y el tipo es una estructura.

Método 2: Usar aserciones de tipo

Otra forma de verificar el tipo de una estructura puede ser usar un cambio de tipo y hacer varias aserciones de tipo. Un cambio de tipo utiliza varias aserciones de tipo en serie y ejecuta el primer tipo coincidente. En este cambio, el caso contiene el tipo que se va a comparar con el tipo presente en la expresión del cambio, y si ninguno de los casos coincide, se evalúa el caso predeterminado.

Sintaxis:

switch optstatement; typeswitchexpression{
case typelist 1: Statement..
case typelist 2: Statement..
...
default: Statement..
}

Ejemplo:

// Golang program to find a struct type
// using type assertions
package main
  
import "fmt"
  
// struct Employee definition
type Employee struct {
    name        string
    employee_id int
}
  
func Teststruct(x interface{}) {
    // type switch
    switch x.(type) {
    case Employee:
        fmt.Println("Employee type")
    case int:
        fmt.Println("int type")
    default:
        fmt.Println("Error")
    }
}
  
func main() {
    // Declaring and initializing a
    // struct using a struct literal
    t := Employee{"Ram", 1234}
    Teststruct(t)
}

Producción:

Employee type