Check data type in golang

In Go (Golang), checking the data type of a variable can be done in several ways, depending on the context and what information you need about the data type. Here are some common methods to check data types:

1. Using Reflection with reflect.TypeOf

The reflect package provides a TypeOf function that returns the reflection Type of the value in the interface{}. This is a common way to check the data type of a variable.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    fmt.Println("type:", reflect.TypeOf(x))
}

2. Type Assertion

Type assertion is used primarily with interfaces. It allows you to check if an interface contains a specific type.

package main

import (
    "fmt"
)

func main() {
    var i interface{} = "Hello"

    s, ok := i.(string)
    fmt.Println(s, ok)

    f, ok := i.(float64)
    fmt.Println(f, ok)

    if s, ok := i.(string); ok {
        fmt.Println(s)
    } else {
        fmt.Println("Value is not a string")
    }
}

3. Type Switch

A type switch is a construct that allows several type assertions in series. It’s useful when you want to perform different actions based on the concrete type of an interface variable.

package main

import (
    "fmt"
)

func do(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("Twice %v is %v\n", v, v*2)
    case string:
        fmt.Printf("%q is %v bytes long\n", v, len(v))
    default:
        fmt.Printf("I don't know about type %T!\n", v)
    }
}

func main() {
    do(21)
    do("hello")
    do(true)
}

4. Comparing with reflect.DeepEqual

Sometimes, you might want to check if two variables are of the same type. reflect.DeepEqual can be used for this, although it’s more commonly used to compare values.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    a := 42
    b := "hello"

    fmt.Println("Same type:", reflect.DeepEqual(a, b))
}

Each of these methods serves different purposes and can be used depending on your specific needs. Remember that using reflection (reflect.TypeOf) can have performance implications and should be used judiciously in performance-critical code.