Yun
129 lines
2.8 KiB
Go
129 lines
2.8 KiB
Go
package convx
|
|
|
|
import (
|
|
"errors"
|
|
"strconv"
|
|
)
|
|
|
|
// interface 转 int64
|
|
func ToInt64(val interface{}) (i int64, err error) {
|
|
if val == nil {
|
|
return 0, errors.New("value is nil")
|
|
}
|
|
|
|
if v, ok := val.(int64); ok {
|
|
return v, nil
|
|
} else if v, ok := val.(int32); ok {
|
|
return int64(v), nil
|
|
} else if v, ok := val.(string); ok {
|
|
// string 转 int64
|
|
// 第二个参数为基数（2~36），第三个参数位大小表示期望转换的结果类型，其值可以为0, 8, 16, 32和64，分别对应 int, int8, int16, int32和int64
|
|
var i int64
|
|
i, err = strconv.ParseInt(v, 10, 64)
|
|
if err != nil {
|
|
return 0, errors.New("string to int64 error")
|
|
}
|
|
return i, nil
|
|
} else if v, ok := val.(float64); ok {
|
|
return int64(v), nil
|
|
} else if v, ok := val.(float32); ok {
|
|
return int64(v), nil
|
|
} else if v, ok := val.(int); ok {
|
|
return int64(v), nil
|
|
} else if v, ok := val.(uint); ok {
|
|
return int64(v), nil
|
|
} else if v, ok := val.(uint32); ok {
|
|
return int64(v), nil
|
|
} else if v, ok := val.(uint64); ok {
|
|
return int64(v), nil
|
|
} else if v, ok := val.(bool); ok {
|
|
if v {
|
|
return 1, nil
|
|
} else {
|
|
return 0, nil
|
|
}
|
|
} else {
|
|
return 0, errors.New("不支持的参数类型")
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// 泛型的实现
|
|
|
|
|
|
// package main
|
|
|
|
// import (
|
|
// "errors"
|
|
// "fmt"
|
|
// "reflect"
|
|
// "strconv"
|
|
// )
|
|
|
|
// 定义一个约束，用于限制可以被转换为int64的类型
|
|
type Int64Convertible interface {
|
|
toInt64() int64
|
|
}
|
|
|
|
// 实现toInt64方法，用于转换为int64
|
|
func (i *int64) toInt64() int64 {
|
|
return *i
|
|
}
|
|
|
|
// 使用泛型约束来定义函数
|
|
func ToInt642[T any](val T) (int64, error) where T: Int64Convertible {
|
|
v := reflect.ValueOf(val)
|
|
t := v.Type()
|
|
|
|
if v.IsNil() {
|
|
return 0, errors.New("值为nil")
|
|
}
|
|
|
|
switch v.Kind() {
|
|
case reflect.String:
|
|
i, err := strconv.ParseInt(v.String(), 10, 64)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("无法将字符串转换为int64: %w", err)
|
|
}
|
|
return i, nil
|
|
case reflect.Bool:
|
|
if v.Bool() {
|
|
return 1, nil
|
|
}
|
|
return 0, nil
|
|
default:
|
|
return v.Interface().(Int64Convertible).toInt64(), nil
|
|
}
|
|
}
|
|
|
|
// 添加对指针类型的处理
|
|
func ToInt64[T any](val T) (int64, error) where T: Int64Convertible {
|
|
v := reflect.ValueOf(val)
|
|
t := v.Type()
|
|
|
|
if v.IsNil() {
|
|
return 0, errors.New("值为nil")
|
|
}
|
|
|
|
if v.Kind() == reflect.Ptr {
|
|
v = v.Elem()
|
|
t = v.Type()
|
|
}
|
|
|
|
switch v.Kind() {
|
|
case reflect.String:
|
|
i, err := strconv.ParseInt(v.String(), 10, 64)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("无法将字符串转换为int64: %w", err)
|
|
}
|
|
return i, nil
|
|
case reflect.Bool:
|
|
if v.Bool() {
|
|
return 1, nil
|
|
}
|
|
return 0, nil
|
|
default:
|
|
return v.Interface().(Int64Convertible).toInt64(), nil
|
|
}
|
|
} |