Go语言中的类型开关（Type Switch）详解

switch variable := interfaceVar.(type) {
case TypeA:
    // 当 interfaceVar 的实际类型是 TypeA 时执行
    // 在此作用域内，variable 的类型是 TypeA
case TypeB:
    // 当 interfaceVar 的实际类型是 TypeB 时执行
    // 在此作用域内，variable 的类型是 TypeB
default:
    // 当没有匹配到任何 case 类型时执行
    // 在此作用域内，variable 的类型是 interface{}
}

package main

import "fmt"

func functionOfSomeType() interface{} {
    // 模拟返回不同类型的值
    // return true
    // return 123
    // return &true
    return "hello" // 默认返回一个未处理的类型
}

func main() {
    var t interface{}
    t = functionOfSomeType() // t 现在持有某个具体类型的值

    switch t := t.(type) {
    default:
        fmt.Printf("unexpected type %T, value: %v\n", t, t) // %T 打印 t 的类型
    case bool:
        fmt.Printf("boolean %t\n", t) // t 在这里是 bool 类型
    case int:
        fmt.Printf("integer %d\n", t) // t 在这里是 int 类型
    case *bool:
        fmt.Printf("pointer to boolean %t\n", *t) // t 在这里是 *bool 类型
    case *int:
        fmt.Printf("pointer to integer %d\n", *t) // t 在这里是 *int 类型
    }
}

package main

import (
    "fmt"
    "time"
)

// NullTime 结构体，用于处理可空的 time.Time
type NullTime struct {
    Time  time.Time
    Valid bool // true if Time is not NULL
}

// 模拟解析日期时间字符串的函数
func parseDateTime(s string, loc *time.Location) (time.Time, error) {
    // 实际实现会更复杂，这里仅为示例
    return time.ParseInLocation("2006-01-02 15:04:05", s, loc)
}

// Scan 实现了 sql.Scanner 接口
func (nt *NullTime) Scan(value interface{}) (err error) {
    if value == nil {
        nt.Time, nt.Valid = time.Time{}, false
        return nil // 明确返回 nil 错误
    }

    switch v := value.(type) {
    case time.Time:
        nt.Time, nt.Valid = v, true
        return
    case []byte:
        nt.Time, err = parseDateTime(string(v), time.UTC)
        nt.Valid = (err == nil)
        return
    case string:
        nt.Time, err = parseDateTime(v, time.UTC)
        nt.Valid = (err == nil)
        return
    }

    nt.Valid = false
    return fmt.Errorf("无法将 %T 类型的值转换为 time.Time", value)
}

func main() {
    var nt NullTime

    // 示例1: 从数据库读取 time.Time 类型
    nt.Scan(time.Now())
    fmt.Printf("Scan time.Time: %+v\n", nt)

    // 示例2: 从数据库读取 []byte 类型（日期时间字符串）
    nt.Scan([]byte("2023-10-26 10:30:00"))
    fmt.Printf("Scan []byte: %+v\n", nt)

    // 示例3: 从数据库读取 string 类型（日期时间字符串）
    nt.Scan("2023-10-26 11:00:00")
    fmt.Printf("Scan string: %+v\n", nt)

    // 示例4: 从数据库读取 nil 值
    nt.Scan(nil)
    fmt.Printf("Scan nil: %+v\n", nt)

    // 示例5: 无法转换的类型
    err := nt.Scan(123)
    fmt.Printf("Scan int (error): %+v, Error: %v\n", nt, err)
}

package main

import (
    "fmt"
    "go/ast"
    "go/parser"
    "go/token"
)

func processNode(node ast.Node) {
    switch n := node.(type) {
    case *ast.Ident:
        fmt.Printf("Identifier: %s (pos: %s)\n", n.Name, n.Pos())
    case *ast.BasicLit:
        fmt.Printf("Basic Literal: %s (value: %s, pos: %s)\n", n.Kind, n.Value, n.Pos())
    case *ast.FuncDecl:
        fmt.Printf("Function Declaration: %s (pos: %s)\n", n.Name.Name, n.Pos())
        // 递归处理函数体
        if n.Body != nil {
            for _, stmt := range n.Body.List {
                processNode(stmt)
            }
        }
    case *ast.AssignStmt:
        fmt.Printf("Assignment Statement (pos: %s)\n", n.Pos())
        for _, expr := range n.Lhs {
            processNode(expr)
        }
        for _, expr := range n.Rhs {
            processNode(expr)
        }
    default:
        // fmt.Printf("Unknown Node Type: %T (pos: %s)\n", n, n.Pos())
    }
}

func main() {
    fset := token.NewFileSet()
    src := `
package main

func main() {
    x := 10
    y := "hello"
    _ = x + y // 这是一个编译错误，但AST仍然可以解析
}
`
    f, err := parser.ParseFile(fset, "", src, 0)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 遍历文件中的所有声明
    for _, decl := range f.Decls {
        processNode(decl)
    }
}