Golang无泛型下的类型断言解决方案（结合GORM场景）

嘿，我完全懂你现在的感受——这段重复的类型断言代码写起来真的很繁琐，尤其是还要兼顾各种指针类型。在Go没有泛型的年代，我们有两种实用的优化思路，能让你的代码清爽不少：

方案1：提取辅助函数，集中处理类型转换 #

把所有类型断言和转换逻辑抽成一个独立的辅助函数，主逻辑只负责时间格式化，彻底避免重复代码：

// toInt64 把各种整数/整数指针类型转换为int64，转换失败返回false
func toInt64(t interface{}) (int64, bool) {
    switch v := t.(type) {
    case int:
        return int64(v), true
    case uint:
        return int64(v), true
    case uint8:
        return int64(v), true
    case int8:
        return int64(v), true
    case int16:
        return int64(v), true
    case uint16:
        return int64(v), true
    case int32:
        return int64(v), true
    case uint32:
        return int64(v), true
    case int64:
        return v, true
    case uint64:
        return int64(v), true
    // 处理指针类型
    case *int:
        return int64(*v), true
    case *uint:
        return int64(*v), true
    case *uint8:
        return int64(*v), true
    case *int8:
        return int64(*v), true
    case *int16:
        return int64(*v), true
    case *uint16:
        return int64(*v), true
    case *int32:
        return int64(*v), true
    case *uint32:
        return int64(*v), true
    case *int64:
        return *v, true
    case *uint64:
        return int64(*v), true
    default:
        return 0, false
    }
}

然后你的模板函数就可以简化成：

f["UNIX2STR"] = func(t interface{}, f string) string {
    ts, ok := toInt64(t)
    if !ok {
        // 这里可以根据业务需求返回默认值，比如空字符串，或者 panic
        return ""
    }
    return time.Unix(ts, 0).Format(f)
}

优点：没有使用反射，性能更优；逻辑清晰，调试起来更直观。
缺点：需要手动维护所有支持的类型，如果后续要加新的整数类型，得手动补充case。

方案2：用反射自动处理指针与整数类型 #

如果不想手动维护所有指针和整数类型，可以用Go的reflect包自动解引用指针，并统一处理所有整数类型：

import "reflect"

// toInt64 利用反射自动处理指针，将整数类型转换为int64
func toInt64(t interface{}) (int64, bool) {
    if t == nil {
        return 0, false
    }

    val := reflect.ValueOf(t)
    // 自动解引用所有层级的指针
    for val.Kind() == reflect.Ptr {
        if val.IsNil() {
            return 0, false
        }
        val = val.Elem()
    }

    // 统一处理所有整数类型
    switch val.Kind() {
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        return val.Int(), true
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
        return int64(val.Uint()), true
    default:
        return 0, false
    }
}

模板函数的调用逻辑和方案1完全一样，这样不管是新增整数类型还是多层指针（比如**int），都能自动处理，不用修改代码。

优点：代码极度简洁，扩展性极强，不用手动维护类型列表；支持多层指针解引用。
缺点：反射有轻微的性能开销，如果这个函数是高频调用场景，需要权衡性能需求。

额外建议 #

关于转换失败的情况，你可以根据实际业务需求调整：比如返回一个默认的时间字符串，或者直接panic（如果传入非法类型属于严重错误），或者返回错误信息。

内容的提问来源于stack exchange，提问作者TomSawyer