数据类型转换工具类

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

`type_transformation_util.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
}

`typeconv_util.go`

将interface{}的值转成对应的值

// Package typeconv 提供安全的 interface{} 到常用类型的转换函数。
package typeconv

import (
	"strconv"
	"strings"
)

// ToInt32 尝试将 v 转为 int32。
// 支持：int/uint/float/string 等。
func ToInt32(v interface{}) (int32, bool) {
	i64, ok := ToInt64(v)
	if !ok {
		return 0, false
	}
	if i64 < -2147483648 || i64 > 2147483647 { // int32 范围检查
		return 0, false
	}
	return int32(i64), true
}

// ToInt64 尝试将 v 转为 int64。
func ToInt64(v interface{}) (int64, bool) {
	switch x := v.(type) {
	case int:
		return int64(x), true
	case int8:
		return int64(x), true
	case int16:
		return int64(x), true
	case int32:
		return int64(x), true
	case int64:
		return x, true

	case uint:
		return int64(x), true
	case uint8:
		return int64(x), true
	case uint16:
		return int64(x), true
	case uint32:
		return int64(x), true
	case uint64:
		if x <= 9223372036854775807 { // math.MaxInt64
			return int64(x), true
		}
		return 0, false

	case float32:
		return int64(x), true
	case float64:
		return int64(x), true

	case string:
		x = strings.TrimSpace(x)
		if x == "" {
			return 0, false
		}
		if i, err := strconv.ParseInt(x, 10, 64); err == nil {
			return i, true
		}
		return 0, false

	case bool:
		return 0, false // 不自动转 bool 为 0/1

	default:
		return 0, false
	}
}

// ToString 尝试将 v 转为 string。
// 特别处理 nil、bool、数字等。
func ToString(v interface{}) (string, bool) {
	if v == nil {
		return "", false
	}
	switch x := v.(type) {
	case string:
		return x, true
	case int, int8, int16, int32, int64:
		return strconv.FormatInt(ToInt64Value(v), 10), true
	case uint, uint8, uint16, uint32, uint64:
		return strconv.FormatUint(ToUint64Value(v), 10), true
	case float32, float64:
		return strconv.FormatFloat(ToFloat64Value(v), 'f', -1, 64), true
	case bool:
		return strconv.FormatBool(x), true
	default:
		return "", false
	}
}

// ToBool 尝试将 v 转为 bool。
// 支持：true/false, "true"/"false", "1"/"0", 1/0 等。
func ToBool(v interface{}) (bool, bool) {
	switch x := v.(type) {
	case bool:
		return x, true
	case string:
		x = strings.ToLower(strings.TrimSpace(x))
		if x == "true" || x == "1" {
			return true, true
		}
		if x == "false" || x == "0" {
			return false, true
		}
		return false, false
	case int, int8, int16, int32, int64:
		i, _ := ToInt64(v)
		return i != 0, true
	case uint, uint8, uint16, uint32, uint64:
		i, _ := ToInt64(v)
		return i != 0, true
	case float32, float64:
		f, _ := ToFloat64(v)
		return f != 0, true
	default:
		return false, false
	}
}

// ToStringSlice 尝试将 v 转为 []string。
// 支持：[]interface{}, []string, 甚至单个 string（转为单元素切片）。
func ToStringSlice(v interface{}) ([]string, bool) {
	if v == nil {
		return nil, false
	}

	// 如果本身就是 []string
	if slice, ok := v.([]string); ok {
		return slice, true
	}

	// 如果是 []interface{}
	if arr, ok := v.([]interface{}); ok {
		result := make([]string, len(arr))
		for i, item := range arr {
			s, ok := ToString(item)
			if !ok {
				return nil, false
			}
			result[i] = s
		}
		return result, true
	}

	// 单个字符串？可选：是否允许自动包装？
	// 这里选择不允许，保持严格性
	return nil, false
}

// ToInt64Slice 尝试将 v 转为 []int64。
// 支持：[]interface{}, []int64, 甚至单个数字（不自动包装）。
func ToInt64Slice(v interface{}) ([]int64, bool) {
	if v == nil {
		return nil, false
	}

	// 如果本身就是 []int64
	if slice, ok := v.([]int64); ok {
		return slice, true
	}

	// 如果是 []interface{}
	if arr, ok := v.([]interface{}); ok {
		result := make([]int64, len(arr))
		for i, item := range arr {
			val, ok := ToInt64(item)
			if !ok {
				return nil, false
			}
			result[i] = val
		}
		return result, true
	}

	// 不支持单个值自动转为切片（保持类型安全）
	return nil, false
}

// ---- 辅助函数（内部使用）----

func ToInt64Value(v interface{}) int64 {
	if i, ok := ToInt64(v); ok {
		return i
	}
	return 0
}

func ToUint64Value(v interface{}) uint64 {
	switch x := v.(type) {
	case uint:
		return uint64(x)
	case uint8:
		return uint64(x)
	case uint16:
		return uint64(x)
	case uint32:
		return uint64(x)
	case uint64:
		return x
	case int:
		if x >= 0 {
			return uint64(x)
		}
	case int8:
		if x >= 0 {
			return uint64(x)
		}
	case int16:
		if x >= 0 {
			return uint64(x)
		}
	case int32:
		if x >= 0 {
			return uint64(x)
		}
	case int64:
		if x >= 0 {
			return uint64(x)
		}
	}
	return 0
}

func ToFloat64(v interface{}) (float64, bool) {
	switch x := v.(type) {
	case float32:
		return float64(x), true
	case float64:
		return x, true
	case int, int8, int16, int32, int64:
		i, ok := ToInt64(v)
		return float64(i), ok
	case uint, uint8, uint16, uint32, uint64:
		i, ok := ToInt64(v)
		return float64(i), ok
	case string:
		x = strings.TrimSpace(x)
		if x == "" {
			return 0, false
		}
		if f, err := strconv.ParseFloat(x, 64); err == nil {
			return f, true
		}
		return 0, false
	default:
		return 0, false
	}
}

func ToFloat64Value(v interface{}) float64 {
	if f, ok := ToFloat64(v); ok {
		return f
	}
	return 0
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259

使用示例

package main

import (
	"fmt"
	"your-module/typeconv" // 替换为你的模块路径
)

func main() {
	// 测试各种转换
	cases := []interface{}{
		"123",
		float64(456),
		[]interface{}{"a", "b"},
		[]interface{}{1, 2, 3},
		"true",
		"1",
		0,
		nil,
	}

	for _, v := range cases {
		if s, ok := typeconv.ToString(v); ok {
			fmt.Printf("ToString(%v) = %q\n", v, s)
		}

		if i, ok := typeconv.ToInt32(v); ok {
			fmt.Printf("ToInt32(%v) = %d\n", v, i)
		}

		if b, ok := typeconv.ToBool(v); ok {
			fmt.Printf("ToBool(%v) = %t\n", v, b)
		}

		if arr, ok := typeconv.ToStringSlice(v); ok {
			fmt.Printf("ToStringSlice(%v) = %v\n", v, arr)
		}

		if iarr, ok := typeconv.ToInt64Slice(v); ok {
			fmt.Printf("ToInt64Slice(%v) = %v\n", v, iarr)
		}
		fmt.Println("---")
	}
}

多线程

go的加解密

数据类型转换工具类

`type_transformation_util.go`

指针转值

值转指针

`typeconv_util.go`

数据类型转换工具类 ​

type_transformation_util.go ​

指针转值 ​

值转指针 ​

typeconv_util.go ​

数据类型转换工具类

`type_transformation_util.go`

指针转值

值转指针

`typeconv_util.go`