Tutorials
Golang
Golang Basics
Type Assertions and Type Switches in Golang

Type Assertions and Type Switches in Golang

Type assertions and type switches are Go’s mechanisms for working with interfaces. They allow you to check the concrete type of a value stored in an interface and extract that value. This is particularly useful when working with empty interfaces (interface{}) or when you need to handle different types in a type-safe way.

Type Assertions

A type assertion provides access to the concrete value stored in an interface. It has two forms: the comma ok form and the direct form.

Basic Type Assertion

basic-assertion.go
package main

import "fmt"

func main() {
    var i interface{} = "hello"
    
    // Direct assertion - panics if wrong type
    s := i.(string)
    fmt.Println("String:", s)
    
    // Comma ok form - safe assertion
    s2, ok := i.(string)
    if ok {
        fmt.Println("Safe string:", s2)
    } else {
        fmt.Println("Not a string")
    }
    
    // Try wrong type
    f, ok := i.(float64)
    if ok {
        fmt.Println("Float:", f)
    } else {
        fmt.Println("Not a float")
    }
}

Working with Concrete Types

concrete-types.go
package main

import "fmt"

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14159 * c.Radius * c.Radius
}

type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func printArea(s Shape) {
    fmt.Printf("Area: %.2f\n", s.Area())
}

func main() {
    shapes := []Shape{
        Circle{Radius: 5},
        Rectangle{Width: 10, Height: 5},
    }
    
    for _, shape := range shapes {
        printArea(shape)
        
        // Type assertion to get concrete type
        if circle, ok := shape.(Circle); ok {
            fmt.Printf("This is a circle with radius %.2f\n", circle.Radius)
        } else if rect, ok := shape.(Rectangle); ok {
            fmt.Printf("This is a rectangle with dimensions %.2f x %.2f\n", rect.Width, rect.Height)
        }
    }
}

Type Switches

Type switches are a more elegant way to handle multiple type assertions. They use the switch statement with type assertions.

Basic Type Switch

basic-switch.go
package main

import "fmt"

func describe(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("Integer: %d\n", v)
    case string:
        fmt.Printf("String: %s (length: %d)\n", v, len(v))
    case bool:
        fmt.Printf("Boolean: %t\n", v)
    case float64:
        fmt.Printf("Float: %.2f\n", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

func main() {
    describe(42)
    describe("hello")
    describe(true)
    describe(3.14)
    describe([]int{1, 2, 3})
}

Type Switch with Multiple Cases

multiple-cases.go
package main

import "fmt"

func classify(x interface{}) {
    switch v := x.(type) {
    case int, int8, int16, int32, int64:
        fmt.Printf("%d is an integer\n", v)
    case uint, uint8, uint16, uint32, uint64:
        fmt.Printf("%d is an unsigned integer\n", v)
    case float32, float64:
        fmt.Printf("%.2f is a floating point number\n", v)
    case string:
        if len(v) > 10 {
            fmt.Printf("'%s' is a long string\n", v)
        } else {
            fmt.Printf("'%s' is a short string\n", v)
        }
    case nil:
        fmt.Println("Value is nil")
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

func main() {
    classify(42)
    classify(uint(100))
    classify(3.14)
    classify("hello")
    classify("this is a very long string indeed")
    classify(nil)
}

Practical Examples

JSON Unmarshaling

json-example.go
package main

import (
    "encoding/json"
    "fmt"
)

func processJSON(data []byte) {
    var result interface{}
    json.Unmarshal(data, &result)
    
    processValue(result)
}

func processValue(v interface{}) {
    switch val := v.(type) {
    case map[string]interface{}:
        fmt.Println("Object:")
        for k, v := range val {
            fmt.Printf("  %s: ", k)
            processValue(v)
        }
    case []interface{}:
        fmt.Println("Array:")
        for i, item := range val {
            fmt.Printf("  [%d]: ", i)
            processValue(item)
        }
    case string:
        fmt.Printf("String: %s\n", val)
    case float64:
        fmt.Printf("Number: %.2f\n", val)
    case bool:
        fmt.Printf("Boolean: %t\n", val)
    case nil:
        fmt.Println("Null")
    default:
        fmt.Printf("Unknown type: %T\n", val)
    }
}

func main() {
    jsonData := `{
        "name": "John",
        "age": 30,
        "active": true,
        "scores": [85, 92, 78],
        "address": {
            "street": "123 Main St",
            "city": "Anytown"
        }
    }`
    
    processJSON([]byte(jsonData))
}

Error Type Checking

error-checking.go
package main

import (
    "errors"
    "fmt"
    "net"
)

func handleError(err error) {
    if err == nil {
        return
    }
    
    switch e := err.(type) {
    case *net.OpError:
        fmt.Printf("Network error: %s\n", e.Op)
    case *net.DNSError:
        fmt.Printf("DNS error: %s\n", e.Name)
    default:
        // Check for wrapped errors
        if errors.Is(err, net.ErrClosed) {
            fmt.Println("Connection closed")
        } else {
            fmt.Printf("Other error: %v\n", err)
        }
    }
}

func main() {
    // Simulate different types of errors
    handleError(&net.OpError{Op: "dial"})
    handleError(&net.DNSError{Name: "example.com"})
    handleError(net.ErrClosed)
    handleError(errors.New("custom error"))
}

Database Result Processing

database-example.go
package main

import (
    "database/sql"
    "fmt"
)

func processRow(rows *sql.Rows) error {
    columns, err := rows.Columns()
    if err != nil {
        return err
    }
    
    values := make([]interface{}, len(columns))
    scanArgs := make([]interface{}, len(columns))
    
    for i := range values {
        scanArgs[i] = &values[i]
    }
    
    for rows.Next() {
        err := rows.Scan(scanArgs...)
        if err != nil {
            return err
        }
        
        for i, col := range columns {
            fmt.Printf("%s: ", col)
            processDatabaseValue(values[i])
        }
        fmt.Println()
    }
    
    return rows.Err()
}

func processDatabaseValue(val interface{}) {
    switch v := val.(type) {
    case nil:
        fmt.Print("NULL")
    case []byte:
        fmt.Printf("%s", string(v))
    case int64:
        fmt.Printf("%d", v)
    case float64:
        fmt.Printf("%.2f", v)
    case bool:
        fmt.Printf("%t", v)
    default:
        fmt.Printf("%v (%T)", v, v)
    }
}

func main() {
    // This is just a demonstration - in real code you'd have an actual database connection
    fmt.Println("Database value processing example")
}

Advanced Patterns

Type Assertion Chains

assertion-chains.go
package main

import "fmt"

func extractString(i interface{}) (string, bool) {
    // Try direct assertion first
    if s, ok := i.(string); ok {
        return s, true
    }
    
    // Try assertion to fmt.Stringer interface
    if stringer, ok := i.(fmt.Stringer); ok {
        return stringer.String(), true
    }
    
    // Try assertion to error interface
    if err, ok := i.(error); ok {
        return err.Error(), true
    }
    
    return "", false
}

func main() {
    var values []interface{} = []interface{}{
        "direct string",
        fmt.Errorf("error: %s", "something went wrong"),
        42, // This won't match any
    }
    
    for _, v := range values {
        if s, ok := extractString(v); ok {
            fmt.Printf("Extracted string: %s\n", s)
        } else {
            fmt.Printf("Could not extract string from %T\n", v)
        }
    }
}

Generic Type Switch Functions

generic-switch.go
package main

import (
    "fmt"
    "reflect"
)

func describeType(i interface{}) {
    t := reflect.TypeOf(i)
    v := reflect.ValueOf(i)
    
    fmt.Printf("Type: %s\n", t.String())
    fmt.Printf("Kind: %s\n", t.Kind())
    
    switch v.Kind() {
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        fmt.Printf("Integer value: %d\n", v.Int())
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
        fmt.Printf("Unsigned integer value: %d\n", v.Uint())
    case reflect.Float32, reflect.Float64:
        fmt.Printf("Float value: %.2f\n", v.Float())
    case reflect.String:
        fmt.Printf("String value: %s (length: %d)\n", v.String(), v.Len())
    case reflect.Bool:
        fmt.Printf("Boolean value: %t\n", v.Bool())
    case reflect.Slice, reflect.Array:
        fmt.Printf("Collection with %d elements\n", v.Len())
    case reflect.Map:
        fmt.Printf("Map with %d key-value pairs\n", v.Len())
    default:
        fmt.Printf("Other type: %s\n", t.String())
    }
}

func main() {
    describeType(42)
    describeType("hello")
    describeType([]int{1, 2, 3})
    describeType(map[string]int{"a": 1, "b": 2})
}

Common Pitfalls

Ignoring the ok Value

pitfall-ok.go
package main

import "fmt"

func badAssertion() {
    var i interface{} = 42
    
    // This will panic if i is not a string
    // s := i.(string)
    
    // This is safe
    if s, ok := i.(string); ok {
        fmt.Println("String:", s)
    } else {
        fmt.Println("Not a string")
    }
}

func main() {
    badAssertion()
}

Type Switch Fallthrough

Type switches don’t support fallthrough like regular switches:

pitfall-fallthrough.go
package main

import "fmt"

func demonstrateFallthrough() {
    var i interface{} = int32(42)
    
    switch v := i.(type) {
    case int:
        fmt.Println("int")
        // No fallthrough available
    case int32:
        fmt.Println("int32")
    case int64:
        fmt.Println("int64")
    default:
        fmt.Printf("other: %T\n", v)
    }
}

func main() {
    demonstrateFallthrough()
}

Best Practices

  1. Use comma ok form - Always use the safe form of type assertion when possible
  2. Prefer type switches - Use type switches when checking multiple types
  3. Handle default cases - Always include a default case in type switches
  4. Document expectations - Make it clear what types you expect
  5. Avoid reflection when possible - Type assertions are usually faster than reflection
  6. Check for nil first - Interface values can be nil
  7. Use meaningful variable names - Use descriptive names in type switches

Performance Considerations

Type assertions have some performance cost, especially when using reflection. For performance-critical code:

performance.go
package main

import (
    "fmt"
    "reflect"
    "time"
)

func typeSwitchAssertion(i interface{}) {
    switch i.(type) {
    case string:
        _ = i.(string)
    case int:
        _ = i.(int)
    }
}

func reflectionAssertion(i interface{}) {
    if reflect.TypeOf(i).Kind() == reflect.String {
        _ = i.(string)
    }
}

func benchmarkAssertions() {
    var i interface{} = "test string"
    
    // Benchmark type switch
    start := time.Now()
    for j := 0; j < 1000000; j++ {
        typeSwitchAssertion(i)
    }
    typeSwitchTime := time.Since(start)
    
    // Benchmark reflection
    start = time.Now()
    for j := 0; j < 1000000; j++ {
        reflectionAssertion(i)
    }
    reflectionTime := time.Since(start)
    
    fmt.Printf("Type switch: %v\n", typeSwitchTime)
    fmt.Printf("Reflection: %v\n", reflectionTime)
    fmt.Printf("Ratio: %.2f\n", float64(reflectionTime)/float64(typeSwitchTime))
}

func main() {
    benchmarkAssertions()
}

External Resources:

Related Tutorials:

Last updated on
Panic and Recover in GolangEmbedding in Golang