How do type assertions and type switches perform internally in Go?

// Single type assertion
var v interface{} = "hello"

// Panicking form — use only when you are certain of the type
s := v.(string)       // panics if v is not a string

// Safe form — never panics
s, ok := v.(string)   // ok=false if wrong type
if !ok {
    // handle mismatch
}

// Type switch — more efficient than chained if assertions
// The compiler generates optimised comparison code
func describe(v interface{}) string {
    switch x := v.(type) {
    case int:     return fmt.Sprintf("int: %d", x)
    case string:  return fmt.Sprintf("string: %q", x)
    case bool:    return fmt.Sprintf("bool: %v", x)
    case []byte:  return fmt.Sprintf("bytes: %d bytes", len(x))
    default:      return fmt.Sprintf("unknown: %T", x)
    }
}

// Performance:
// Single type assertion: ~1-3 ns — pointer comparison on the type word
// Type switch with many cases: O(n) comparisons unless compiler optimises
// For hot paths with many types: use a map[reflect.Type]func() or generics

// Interface-to-interface assertion: also cheap (same mechanism)
type Stringer interface{ String() string }
var r io.Reader = os.Stdin
if s, ok := r.(Stringer); ok {
    fmt.Println(s.String()) // os.File implements Stringer
}