数据类型转换工具类

go的类型转换真的烦！！！！！！！

type_transformation.go

指针转值

func StringVal(p *string) string {
    if p == nil {
        return ""
    }
    return *p
}

func IntVal(p *int) int {
    if p == nil {
        return 0
    }
    return *p
}

func Int32Val(p *int32) int32 {
    if p == nil {
        return 0
    }
    return *p
}

func Int64Val(p *int64) int64 {
    if p == nil {
        return 0
    }
    return *p
}

func TimeVal(p *time.Time) int64 {
    if p == nil {
        return 0
    }
    return p.Unix()
}

值转指针

// Package ptr 提供快速创建基本类型指针的辅助函数。
// 常用于 GORM 模型初始化、API 请求体构造、可选配置字段等场景。
package ptr

import "time"

// String 返回字符串指针
func String(v string) *string {
	return &v
}

// Int 返回整型指针
func Int(v int) *int {
	return &v
}

// Int8 返回 int8 指针
func Int8(v int8) *int8 {
	return &v
}

// Int16 返回 int16 指针
func Int16(v int16) *int16 {
	return &v
}

// Int32 返回 int32 指针
func Int32(v int32) *int32 {
	return &v
}

// Int64 返回 int64 指针
func Int64(v int64) *int64 {
	return &v
}

// Uint 返回 uint 指针
func Uint(v uint) *uint {
	return &v
}

// Uint8 返回 uint8 指针
func Uint8(v uint8) *uint8 {
	return &v
}

// Uint16 返回 uint16 指针
func Uint16(v uint16) *uint16 {
	return &v
}

// Uint32 返回 uint32 指针
func Uint32(v uint32) *uint32 {
	return &v
}

// Uint64 返回 uint64 指针
func Uint64(v uint64) *uint64 {
	return &v
}

// Float32 返回 float32 指针
func Float32(v float32) *float32 {
	return &v
}

// Float64 返回 float64 指针
func Float64(v float64) *float64 {
	return &v
}

// Bool 返回布尔值指针
func Bool(v bool) *bool {
	return &v
}

// Byte 返回 byte（uint8）指针
func Byte(v byte) *byte {
	return &v
}

// Time 返回 time.Time 指针
func Time(t time.Time) *time.Time {
	return &t
}

// Any 返回任意类型的指针（泛型）
func Any[T any](v T) *T {
	return &v
}

StructToMap

package bean_cover_util

import (
	"reflect"
	"strings"
)

// StructToMap 将结构体转换为 map[string]interface{}。
//
// 支持：
//   - 指针或值类型的 struct
//   - json tag 解析（忽略 `,omitempty` 等修饰）
//   - 嵌套 struct 转 map
//   - struct slice 转 []map[string]interface{}
//
// 规则：
//   - 忽略 json:"-" 或无 json tag 的字段
//   - 若 tag 包含 ,（如 "name,omitempty"），仅取前面部分
//   - 若 tag 为空，则使用小驼峰字段名（fieldName）
//   - 非导出字段（小写开头）不会被反射访问
func StructToMap(v interface{}) map[string]interface{} {
	m := make(map[string]interface{})
	rv := reflect.ValueOf(v)

	// 解引用指针
	if rv.Kind() == reflect.Ptr {
		rv = rv.Elem()
	}

	// 确保是结构体
	if rv.Kind() != reflect.Struct {
		return m
	}

	rt := rv.Type()
	for i := 0; i < rv.NumField(); i++ {
		field := rt.Field(i)
		value := rv.Field(i)

		// 获取 json tag
		tag := field.Tag.Get("json")
		if tag == "-" || tag == "" {
			continue
		}

		// 去除 tag 中的选项（如 ",omitempty"）
		if idx := strings.Index(tag, ","); idx != -1 {
			tag = tag[:idx]
		}

		// 如果 tag 为空，使用小驼峰字段名
		if tag == "" {
			tag = strings.ToLower(field.Name[:1]) + field.Name[1:]
		}

		// 处理嵌套结构体
		if value.Kind() == reflect.Struct {
			m[tag] = StructToMap(value.Interface())
		} else if value.Kind() == reflect.Slice {
			// 处理 []struct 类型
			elemKind := value.Type().Elem().Kind()
			if elemKind == reflect.Struct {
				sliceMap := make([]interface{}, value.Len())
				for j := 0; j < value.Len(); j++ {
					sliceMap[j] = StructToMap(value.Index(j).Interface())
				}
				m[tag] = sliceMap
			} else {
				// 普通 slice（如 []string, []int）
				m[tag] = value.Interface()
			}
		} else {
			// 基本类型直接赋值
			m[tag] = value.Interface()
		}
	}

	return m
}