How to find the type of Struct in Golang?

A structure or struct in Golang is a user-defined data type which is a composition of various data fields. Each data field has its own data type, which can be a built-in or another user-defined type. Struct represents any real-world entity that has some set of properties/fields. Go does not support the concept of classes, structs are the only way to create a user-defined type in this language. There are various ways by which we can identify the type of struct in Go: Method 1: Using reflect package You can use the reflect package to find the given type of a struct. Reflection package allows determining the variables' type at runtime. Syntax:

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

or

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

Example: C

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())
}

Output:

main.Student
struct
main.Student
struct

Method reflect.TypeOf returns main.Student type while the reflect.Kind returns a struct. It is because the method reflect.TypeOf returns a variable of type reflect.Type. reflect.Type contains all the information about the type that defines the variable that was passed, in this case, Student. The kind tells what this type is made initially of- a pointer, an int, a string, a struct, an interface, or another built-in data type. In our case, the type is a Student, and the kind is a struct. Method 2: Using type assertions Another way to check a struct's type can be by using a type switch and doing several type assertions. A type switch uses several type assertions in series and runs the first matching type. In this switch, the case contains the type which is going to compare with the type present in the switch expression, and if none of the cases matches, then the default case is evaluated. Syntax:

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

Example: C

// 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)
}

Output:

Employee type