Golang Type Assertion And Type Switch Complete Guide

Top 10 Questions and Answers on GoLang Type Assertion and Type Switch

1. What is Type Assertion in GoLang?

Answer: In GoLang, a type assertion provides access to an interface value's underlying concrete value. The syntax for a type assertion is v := i.(T), where v is a variable that will hold the underlying value of the interface i if it is of type T. If i does not hold a value of type T, a runtime panic occurs.

Example:

var i interface{} = "hello"
s := i.(string)
fmt.Println(s) // Output: hello

2. How can Type Assertion be used to check if an interface holds a specific type?

Answer: To safely check whether an interface variable holds a value of a specific type without causing a panic, the type assertion can return two values. The second value is a boolean indicating whether the assertion succeeded.

Example:

var i interface{} = "hello"
s, ok := i.(string)
fmt.Println(s, ok) // Output: hello true

f, ok := i.(float64)
fmt.Println(f, ok) // Output: 0 false

3. What is Type Switch in GoLang?

Answer: Type switch is a construct that allows multiple type assertions in a single statement. It is used to compare the type of an interface variable against several types and execute a block of code for the matching type. The syntax includes the keyword switch followed by an expression v.(type).

Example:

func printType(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)
    }
}
printType(21)    // Output: Twice 21 is 42
printType("hi")  // Output: "hi" is 2 bytes long
printType(true)  // Output: I don't know about type bool!

4. Can a type switch have a default case?

Answer: Yes, a type switch can have a default case like a regular switch case. When no case matches the type of the interface variable, the default block is executed.

Example:

var i interface{} = true
switch i.(type) {
case int:
    fmt.Println("It's an int")
case string:
    fmt.Println("It's a string")
default:
    fmt.Println("It's something else") // Output: It's something else
}

5. Is a type assertion or type switch more efficient?

Answer: Between type assertion and type switch, type switches are more efficient when you want to check multiple types. Type assertions require writing separate code blocks for each type you want to check, whereas a type switch can handle multiple types in a single block.

Example:

// With Type Assertion
if v, ok := i.(int); ok {
    // do something
} else if v, ok := i.(string); ok {
    // do something
}

// With Type Switch
switch v := i.(type) {
case int:
    // do something
case string:
    // do something
}

6. Can you perform multiple type assertions in a single line?

Answer: No, you cannot perform multiple type assertions in a single line. Each type assertion can only check a single type. To check multiple types, use a type switch.

7. What happens if a type assertion fails?

Answer: If a type assertion fails, and the second argument (the boolean flag) is not used to check the result, it will result in a runtime panic. However, using the second argument safely handles the failure.

Example:

var i interface{} = "hello"
s := i.(float64) // Runtime panic: interface conversion: interface {} is string, not float64

8. Do you need an interface to use type assertions or type switches?

Answer: Yes, both type assertions and type switches require an interface variable. They are used to determine the underlying type of the value that an interface holds.

9. Can you use type switches with custom structs or types?

Answer: Absolutely, you can use type switches with any type, including structs, slices, maps, arrays, and custom types. The type switch checks the concrete type of the interface variable.

Example:

type MyType struct {
    Value int
}

func printType(v interface{}) {
    switch v.(type) {
    case MyType:
        fmt.Println("It's a MyType struct")
    default:
        fmt.Println("It's something else")
    }
}

10. How does GoLang handle type assertions and switches with nil interfaces?

Answer: When using a type switch on a nil interface, the concrete type is nil, and there will be no matching cases unless you handle the nil explicitly. For a type assertion, if the interface is nil, the assertion will fail if the target type is not interface{}.

Example: