تأكيدات الأنواع وعبارات type switch

package main
import "fmt"

func main() {
    var i interface{} = "hello"
    s := i.(string)          // panics if wrong type
    fmt.Println(s, len(s))   // hello 5
}

package main
import "fmt"

func main() {
    var i interface{} = 42
    s, ok := i.(string)
    fmt.Println(s, ok)  // "" false
    n, ok := i.(int)
    fmt.Println(n, ok)  // 42 true
}

package main
import "fmt"

func describe(i interface{}) string {
    switch v := i.(type) {
    case int:    return fmt.Sprintf("int: %d", v)
    case string: return fmt.Sprintf("string: %q", v)
    case bool:   return fmt.Sprintf("bool: %v", v)
    default:     return fmt.Sprintf("unknown: %T", v)
    }
}

func main() {
    fmt.Println(describe(42))
    fmt.Println(describe("hi"))
    fmt.Println(describe(3.14))
}

package main
import ("errors"; "fmt")

type NotFoundError struct{ Name string }
func (e *NotFoundError) Error() string { return e.Name + " not found" }

type PermError struct{}
func (e *PermError) Error() string { return "permission denied" }

func handle(err error) {
    switch e := err.(type) {
    case *NotFoundError: fmt.Println("missing:", e.Name)
    case *PermError:     fmt.Println("perm error")
    default:             fmt.Println("other:", e)
    }
}

func main() {
    handle(&NotFoundError{"user"})
    handle(errors.New("generic"))
}

package main
import "fmt"

type Flusher interface{ Flush() }

type Writer interface{ Write(string) }

type BufferedWriter struct{ buf string }
func (b *BufferedWriter) Write(s string) { b.buf += s }
func (b *BufferedWriter) Flush()         { fmt.Println(b.buf); b.buf = "" }

func maybeFlush(w Writer) {
    if f, ok := w.(Flusher); ok { f.Flush() }
}

func main() {
    bw := &BufferedWriter{}
    bw.Write("hello")
    maybeFlush(bw)
}

package main
import "fmt"

func safePrint(i interface{}) {
    if i == nil {
        fmt.Println("nil")
        return
    }
    fmt.Printf("%T: %v\n", i, i)
}

func main() {
    safePrint(nil)
    safePrint(42)
}

package main
import ("fmt"; "reflect")

func main() {
    v := []int{1, 2, 3}
    fmt.Printf("%T\n", v)             // []int
    fmt.Println(reflect.TypeOf(v))    // []int
}

package main
import "fmt"

func main() {
    var i interface{} = int32(5)
    n := i.(int32)          // assertion — OK
    big := int64(n)         // conversion — OK
    fmt.Println(n, big)
}