Go语言中的Type Switch：深度解析接口类型判断机制

switch v := i.(type) {
case Type1:
    // 当 i 的实际类型是 Type1 时执行
    // 此时 v 的类型为 Type1
case Type2:
    // 当 i 的实际类型是 Type2 时执行
    // 此时 v 的类型为 Type2
case nil:
    // 当 i 是一个 nil 接口时执行
default:
    // 当 i 的实际类型不匹配任何 case 时执行
    // 此时 v 的类型与 i 相同，即 interface{}
}

package main

import (
    "fmt"
    "reflect" // 引入 reflect 包用于演示类型名称
)

// 定义一个简单的接口
type Shape interface {
    Area() float64
}

// 实现 Shape 接口的结构体
type Circle struct {
    Radius float64
}

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

// 另一个实现 Shape 接口的结构体
type Rectangle struct {
    Width, Height float64
}

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

func processValue(val interface{}) {
    fmt.Printf("处理值: %v (类型: %T)\n", val, val)

    switch v := val.(type) {
    case nil:
        fmt.Println("这是一个 nil 值。")
    case bool:
        fmt.Printf("这是一个布尔值: %t\n", v) // v 在此是 bool 类型
    case int:
        fmt.Printf("这是一个整数: %d\n", v)     // v 在此是 int 类型
    case string:
        fmt.Printf("这是一个字符串: \"%s\"\n", v) // v 在此是 string 类型
    case Circle:
        fmt.Printf("这是一个圆形，半径为: %.2f，面积为: %.2f\n", v.Radius, v.Area()) // v 在此是 Circle 类型
    case Rectangle:
        fmt.Printf("这是一个矩形，宽度: %.2f，高度: %.2f，面积为: %.2f\n", v.Width, v.Height, v.Area()) // v 在此是 Rectangle 类型
    default:
        fmt.Printf("未知类型: %s\n", reflect.TypeOf(val).String()) // val 在此仍是 interface{} 类型
    }
    fmt.Println("--------------------")
}

func main() {
    processValue(true)
    processValue(123)
    processValue("hello Go")
    processValue(Circle{Radius: 5})
    processValue(Rectangle{Width: 4, Height: 6})
    processValue(nil) // 传入 nil
    processValue(3.14159) // 浮点数，会进入 default
}

package main

import (
    "database/sql"
    "fmt"
    "time"
)

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

// Scan 实现了 sql.Scanner 接口
// 它将数据库中的值扫描到 NullTime 结构体中
func (nt *NullTime) Scan(value interface{}) error {
    if value == nil {
        nt.Time, nt.Valid = time.Time{}, false
        return nil
    }

    switch v := value.(type) {
    case time.Time:
        nt.Time, nt.Valid = v, true
        return nil
    case []byte:
        // 假设 parseDateTime 函数能将 []byte 转换为 time.Time
        // 实际应用中可能需要更复杂的错误处理
        parsedTime, err := time.Parse("2006-01-02 15:04:05", string(v))
        if err != nil {
            nt.Valid = false
            return fmt.Errorf("无法解析字节数组到时间: %w", err)
        }
        nt.Time, nt.Valid = parsedTime, true
        return nil
    case string:
        // 假设 parseDateTime 函数能将 string 转换为 time.Time
        parsedTime, err := time.Parse("2006-01-02 15:04:05", v)
        if err != nil {
            nt.Valid = false
            return fmt.Errorf("无法解析字符串到时间: %w", err)
        }
        nt.Time, nt.Valid = parsedTime, true
        return nil
    default:
        nt.Valid = false
        return fmt.Errorf("无法将 %T 类型转换为 time.Time", value)
    }
}

func main() {
    // 模拟数据库扫描操作
    var nt NullTime

    // 模拟 time.Time 类型输入
    _ = nt.Scan(time.Now())
    if nt.Valid {
        fmt.Printf("从 time.Time 扫描: %s\n", nt.Time.Format(time.RFC3339))
    }

    // 模拟 []byte 类型输入
    _ = nt.Scan([]byte("2023-10-26 10:30:00"))
    if nt.Valid {
        fmt.Printf("从 []byte 扫描: %s\n", nt.Time.Format(time.RFC3339))
    }

    // 模拟 string 类型输入
    _ = nt.Scan("2023-11-15 14:00:00")
    if nt.Valid {
        fmt.Printf("从 string 扫描: %s\n", nt.Time.Format(time.RFC3339))
    }

    // 模拟 nil 输入
    _ = nt.Scan(nil)
    if !nt.Valid {
        fmt.Println("从 nil 扫描: 无效时间")
    }

    // 模拟未知类型输入
    err := nt.Scan(123)
    if err != nil {
        fmt.Printf("从 int 扫描失败: %v\n", err)
    }
}