Go Type Assertions

Assertion in Go

In Go, an interface is a powerful abstraction that allows us to decouple the implementation from the behavior. Essentially, an interface defines a set of methods, and any type that implements these methods satisfies the interface. This enables us to write flexible and reusable code. But there are times when we need to extract the concrete data stored within an interface. This is where type assertions come into play.

What is a Type Assertion?

A type assertion is a way to retrieve the underlying concrete value from an interface. It’s like telling Go, “I know that this interface contains a specific type, give me the value of that type.” Here’s the basic syntax of a type assertion:

value := interfaceValue.(ConcreteType)

In this syntax, interfaceValue is the interface holding the concrete data, and ConcreteType is the type you expect to be inside the interface. If the assertion is correct, you get the concrete value. If not, your program will panic at runtime.

Example of a Type Assertion

Consider we have an interface I that holds some user data:

var i I
// some operations that assign a concrete type to i

To extract the concrete user value from i, you can use:

user := i.(User)

If i indeed contains a User type, user will be assigned the value stored in i. However, if i does not contain a User, the program will panic.

Get Devpriya Shivani’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Safe Type Assertion

To avoid panic, Go provides a safe way to perform type assertions. This method uses a second return value, typically named ok, which indicates whether the assertion was successful or not:

user, ok := i.(User)
if ok {
    // i contains a User, and user is assigned the value
    fmt.Println("User found:", user)
} else {
    // i does not contain a User, handle the error
    fmt.Println("User not found")
}

In this approach, if i contains a User, ok will be true and user will have the value. If i does not contain a User, ok will be false and user will be the zero value of the User type.

Type Assertions with Interfaces

Type assertions are not limited to concrete types. You can also assert that the concrete value inside an interface implements another interface. For instance:

var r io.Reader
reader, ok := i.(io.Reader)
if ok {
    // i contains a type that implements io.Reader
    fmt.Println("i contains an io.Reader")
} else {
    // i does not contain an io.Reader
    fmt.Println("i does not contain an io.Reader")
}

In this example, if i holds a value that satisfies the io.Reader interface, reader will be assigned that value, and ok will be true.

Complete Code:

package main

import "fmt"

type Printer interface {
 print()
}

type User struct {
 name string
}

func (u User) print() {
 fmt.Printf("User Name: %s\n", u.name)
}

func main() {
 u := User{"Devpriya"}
 entities := []Printer{u, &u}
 u.name = "Deva"

 for _, i := range entities {
  user, ok := i.(User)
  if ok {
   fmt.Println("User found:", user)
  } else {
   fmt.Println("User not found")
  }
 }
}

Output:

User found: {Devpriya}
User not found

Conclusion

Type assertions in Go provide a powerful way to work with interfaces, allowing you to extract and manipulate the underlying concrete data safely and efficiently. By understanding and utilizing both basic and safe type assertions, you can write more robust and error-resistant Go programs. Always remember to handle the cases where the type assertion might fail, ensuring your program can handle unexpected types gracefully.

Reference

Go Syntax — Type Assertions