cytype

package
v1.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 27, 2026 License: MIT Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ToString = ToStr

Functions

func Deserialize 

func Deserialize[T any](data []byte) (T, error)

Deserialize 使用 gob 解码将字节数组反序列化为类型 T 的值。 这是一个泛型函数，需要在编译时指定目标类型。

注意：

  • Deserialize[T] 只能反序列化 Serialize[T] 生成的数据
  • 不能反序列化 SerializeAny 生成的数据（数据格式不兼容）
  • T 可以是值类型（Person）或指针类型（*Person）

参数：

  • data: 要反序列化的字节数组（由 Serialize[T] 生成）

返回值：

  • T: 反序列化后的值
  • error: 如果反序列化失败返回错误

示例： 

type User struct { Name string; Age int }
data, _ := Serialize(User{Name: "Alice", Age: 30})
user, err := Deserialize[User](data)
fmt.Println(user.Name, user.Age) // Alice 30

func DeserializeAny 

func DeserializeAny(data []byte) (any, error)

DeserializeAny 反序列化 SerializeAny 生成的数据。 会根据数据中的类型信息和复杂类型标志进行反序列化。

返回值类型：

  • 基础类型：返回原始类型（int, string, bool, []int, []string 等）
  • 复杂类型：返回 map[string]any（struct、map）或 []any（复杂切片）

重要限制：

  • DeserializeAny 只能反序列化 SerializeAny 生成的数据
  • 不能反序列化 Serialize[T] 生成的数据（数据格式不兼容）
  • 复杂类型无法恢复原始类型，需要手动转换
  • JSON 转换导致的类型变化：数字变成 float64

参数：

  • data: 要反序列化的字节数组（由 SerializeAny 生成）

返回值：

  • any: 反序列化后的值
  • error: 如果反序列化失败返回错误

示例： 

// 基础类型
data, _ := SerializeAny(42)
result, _ := DeserializeAny(data)
fmt.Printf("%v (%T)\n", result, result) // 42 (int)

// 复杂类型
type Person struct { Name string; Age int }
data, _ := SerializeAny(Person{Name: "Alice", Age: 30})
result, _ := DeserializeAny(data)
m := result.(map[string]any)
fmt.Println(m["Name"], m["Age"]) // Alice 30 (注意：Age 是 float64)

func Diff 

func Diff(oldDatas, newDatas []map[string]interface{}, key string) (newData, updateData, delData []map[string]interface{})

func FormatTime 

func FormatTime(value interface{}, layout string) string

FormatTime 将任意类型转换为指定格式的时间字符串，失败返回空字符串。

参数:

  • value: 需要转换的值（支持 time.Time、string、int、int64、float64 等）
  • layout: 时间格式（如 "2006-01-02 15:04:05"）

返回值:

  • string: 格式化后的时间字符串，失败返回空字符串

特点:

  • 支持多种输入类型自动转换
  • 失败时返回空字符串（不返回错误）
  • 支持指针类型

使用示例:

  • FormatTime(time.Now(), "2006-01-02") → "2024-01-15"
  • FormatTime(int64(1700000000), "2006-01-02 15:04:05") → "2023-11-15 06:13:20"
  • FormatTime("2024-01-15", "2006-01-02") → "2024-01-15"

func FormatTimeE 

func FormatTimeE(value interface{}, layout string) (string, error)

FormatTimeE 将任意类型转换为指定格式的时间字符串，返回错误。

参数:

  • value: 需要转换的值（支持 time.Time、string、int、int64、float64 等）
  • layout: 时间格式（如 "2006-01-02 15:04:05"）

返回值:

  • string: 格式化后的时间字符串
  • error: 如果转换或格式化失败返回错误

特点:

  • 支持多种输入类型自动转换
  • 返回详细的错误信息
  • 支持指针类型

使用示例:

  • FormatTimeE(time.Now(), "2006-01-02")
  • FormatTimeE(int64(1700000000), "2006-01-02 15:04:05")
  • FormatTimeE("2024-01-15", "2006-01-02")

func FromJson 

func FromJson[T any](b string) *T

func FromJson2 

func FromJson2[T any](b json.RawMessage) *T

func FromJson2E 

func FromJson2E[T any](b json.RawMessage) (*T, error)

func FromJsonE 

func FromJsonE[T any](b string) (*T, error)

func GetBool 

func GetBool(m map[string]interface{}, key string, igoreCase ...bool) bool

GetBool 从 Map 中获取布尔值。

参数:

  • m: Map 对象
  • key: 键名，支持点号分隔的嵌套访问
  • igoreCase: 可选，是否忽略大小写

返回值:

  • bool: 获取到的布尔值，不存在或为 nil 返回 false

用法: 

data := map[string]interface{}{"active": true}
active := GetBool(data, "active")      // true

func GetBoolE 

func GetBoolE(m map[string]interface{}, key string, igoreCase ...bool) (bool, error)

GetBoolE 从 Map 中获取布尔值，返回错误。

参数:

  • m: Map 对象
  • key: 键名，支持点号分隔的嵌套访问
  • igoreCase: 可选，是否忽略大小写

返回值:

  • bool: 获取到的布尔值
  • error: 如果键不存在或转换失败返回错误

func GetFloat 

func GetFloat(m map[string]interface{}, key string, igoreCase ...bool) float64

GetFloat 从 Map 中获取浮点数值。

参数:

  • m: Map 对象
  • key: 键名，支持点号分隔的嵌套访问
  • igoreCase: 可选，是否忽略大小写

返回值:

  • float64: 获取到的浮点数值，不存在或为 nil 返回 0

用法: 

data := map[string]interface{}{"price": 99.99}
price := GetFloat(data, "price")       // 99.99

func GetFloatE 

func GetFloatE(m map[string]interface{}, key string, igoreCase ...bool) (float64, error)

GetFloatE 从 Map 中获取浮点数值，返回错误。

参数:

  • m: Map 对象
  • key: 键名，支持点号分隔的嵌套访问
  • igoreCase: 可选，是否忽略大小写

返回值:

  • float64: 获取到的浮点数值
  • error: 如果键不存在或转换失败返回错误

func GetInt 

func GetInt(m map[string]interface{}, key string, igoreCase ...bool) int

GetInt 从 Map 中获取整数值。

参数:

  • m: Map 对象
  • key: 键名，支持点号分隔的嵌套访问
  • igoreCase: 可选，是否忽略大小写

返回值:

  • int: 获取到的整数值，不存在或为 nil 返回 0

用法: 

data := map[string]interface{}{"count": 42, "user": map[string]interface{}{"id": 123}}
count := GetInt(data, "count")         // 42
id := GetInt(data, "user.id")          // 123

func GetInt64 

func GetInt64(m map[string]interface{}, key string, igoreCase ...bool) int64

GetInt64 从 Map 中获取 int64 值。

参数:

  • m: Map 对象
  • key: 键名，支持点号分隔的嵌套访问
  • igoreCase: 可选，是否忽略大小写

返回值:

  • int64: 获取到的 int64 值，不存在或为 nil 返回 0

用法: 

data := map[string]interface{}{"id": int64(9223372036854775807)}
id := GetInt64(data, "id")

func GetInt64E 

func GetInt64E(m map[string]interface{}, key string, igoreCase ...bool) (int64, error)

GetInt64E 从 Map 中获取 int64 值，返回错误。

参数:

  • m: Map 对象
  • key: 键名，支持点号分隔的嵌套访问
  • igoreCase: 可选，是否忽略大小写

返回值:

  • int64: 获取到的 int64 值
  • error: 如果键不存在或转换失败返回错误

func GetIntE 

func GetIntE(m map[string]interface{}, key string, igoreCase ...bool) (int, error)

GetIntE 从 Map 中获取整数值，返回错误。

参数:

  • m: Map 对象
  • key: 键名，支持点号分隔的嵌套访问
  • igoreCase: 可选，是否忽略大小写

返回值:

  • int: 获取到的整数值
  • error: 如果键不存在或转换失败返回错误

func GetStr 

func GetStr(m map[string]interface{}, key string, igoreCase ...bool) string

GetStr 从 Map 中获取字符串值。

参数:

  • m: Map 对象
  • key: 键名，支持点号分隔的嵌套访问（如 "user.name"）
  • igoreCase: 可选，是否忽略大小写

返回值:

  • string: 获取到的字符串值，不存在或为 nil 返回空字符串

用法: 

data := map[string]interface{}{"name": "John", "user": map[string]interface{}{"age": 30}}
name := GetStr(data, "name")           // "John"
age := GetStr(data, "user.age")        // "30"
missing := GetStr(data, "missing")     // ""

局限:

  • 嵌套访问使用点号分隔
  • 不存在的键返回空字符串

func GetStrE 

func GetStrE(m map[string]interface{}, key string, igoreCase ...bool) (string, error)

GetStrE 从 Map 中获取字符串值，返回错误。

参数:

  • m: Map 对象
  • key: 键名，支持点号分隔的嵌套访问
  • igoreCase: 可选，是否忽略大小写

返回值:

  • string: 获取到的字符串值
  • error: 如果键不存在返回错误

用法: 

data := map[string]interface{}{"name": "John"}
name, err := GetStrE(data, "name")
if err != nil {
    log.Fatal(err)
}

func GetStructFieldTags 

func GetStructFieldTags[T any](tagName string, tagKey ...string) ([]string, error)

GetStructFieldTags 提取结构体字段上的指定标签。

用法: 

type User struct {
	ID   int    `db:"id"`
	Name string `db:"name;comment:用户名"`
	CommonFields
}

tags, _ := GetStructFieldTags[User]("db")              // []string{"id", "name;comment:用户名", ...}
comments, _ := GetStructFieldTags[User]("db", "comment") // []string{"用户名", ...}

局限:

  • T 必须是 struct 或 *struct；其他类型会返回错误。
  • 仅扫描匿名嵌入字段；普通字段中的自定义 struct 不会递归深入。
  • tagKey 仅返回 tag 内指定 key 的第一段值，复杂解析需要自行处理。

func GetVal 

func GetVal[T any](m map[string]interface{}, key string, igoreCase ...bool) T

GetVal 从 Map 中获取泛型类型的值。

参数:

  • m: Map 对象
  • key: 键名，支持点号分隔的嵌套访问
  • igoreCase: 可选，是否忽略大小写

返回值:

  • T: 获取到的值，类型为 T

用法: 

data := map[string]interface{}{"count": 42}
count := GetVal[int](data, "count")  // 42

局限:

  • 必须提供正确的类型参数
  • 类型转换失败时会 panic

func GetValue 

func GetValue(m map[string]interface{}, keys []string, ignoreCase ...bool) (interface{}, error)

GetValue 从 Map 中获取值，支持嵌套路径。

参数:

  • m: 源 Map
  • keys: 键路径数组（如 []string{"user", "name"}）
  • ignoreCase: 可选，是否忽略大小写

返回值:

  • interface{}: 获取到的值
  • error: 如果路径不存在返回错误

用法: 

data := map[string]interface{}{"user": map[string]interface{}{"name": "John"}}
val, err := GetValue(data, []string{"user", "name"})
// val = "John"

特点:

  • 支持任意深度的嵌套
  • 支持忽略大小写查找
  • 路径不存在时返回错误

func IsDigits 

func IsDigits(s string) bool

IsDigits 检查字符串是否全由数字组成。

参数:

  • s: 需要检查的字符串

返回值:

  • bool: 全为数字返回 true，否则返回 false

用法: 

if IsDigits("12345") {
    fmt.Println("All digits")
}
if !IsDigits("123a45") {
    fmt.Println("Contains non-digit")
}

局限:

  • 空字符串返回 false
  • 只检查 Unicode 数字字符

func MD5 

func MD5(params ...interface{}) string

MD5 函数需要从 crypto 包导入，这里声明为外部函数

func MergeMaps 

func MergeMaps(m1 ...map[string]interface{}) map[string]interface{}

MergeMaps 合并多个 Map。

参数:

  • m1: 可变参数，多个 Map 对象

返回值:

  • map[string]interface{}: 合并后的 Map

用法: 

m1 := map[string]interface{}{"a": 1}
m2 := map[string]interface{}{"b": 2}
merged := MergeMaps(m1, m2)  // {"a": 1, "b": 2}

特点:

  • 后面的 Map 会覆盖前面的相同键
  • 空参数返回 nil
  • 单个参数直接返回该 Map

func NewObj 

func NewObj[T any]() (T, bool)

NewObj 创建指针类型的新对象。

返回值:

  • T: 新创建的指针对象
  • bool: 是否成功创建（T 必须是指针类型）

用法: 

	type User struct {
	    Name string
	}
	user, ok := NewObj[*User]()
	if ok {
	    user.Name = "John"
	}

  - T 是指针类型，返回 true

func Ptr 

func Ptr[T any](v T) *T

Ptr 获取值的指针。

参数:

  • v: 需要获取指针的值

返回值:

  • *T: 值的指针

用法: 

value := 42
ptr := Ptr(value)
fmt.Println(*ptr)  // 42

局限:

  • 返回的指针指向新创建的值，不是原始值的指针

func Serialize 

func Serialize[T any](v T) ([]byte, error)

Serialize 使用 gob 编码将类型 T 的值序列化为字节数组。 这是一个泛型函数，适用于类型已知的场景。

注意：

  • Serialize 生成的数据只能用 Deserialize[T] 反序列化
  • 不能与 SerializeAny/DeserializeAny 混用
  • 适用于类型安全的场景

参数：

  • v: 要序列化的值（类型 T）

返回值：

  • []byte: 序列化后的字节数组
  • error: 如果序列化失败返回错误

示例： 

type User struct { Name string; Age int }
data, err := Serialize(User{Name: "Alice", Age: 30})
user, err := Deserialize[User](data)

func SerializeAny 

func SerializeAny(v any) ([]byte, error)

SerializeAny 序列化任意类型的值，并在数据中包含类型信息。 对于复杂类型（struct、map、复杂切片），会先通过 JSON 转换成 map[string]any 或 []any。

数据格式：[类型名长度(4字节)] + [类型名] + [复杂类型标志(1字节)] + [gob数据]

重要限制：

  • SerializeAny 生成的数据只能用 DeserializeAny 反序列化
  • 不能与 Serialize[T]/Deserialize[T] 混用（数据格式不兼容）
  • 复杂类型会丢失原始类型信息，反序列化后变成 map[string]any 或 []any
  • JSON 转换会导致数字变成 float64，私有字段丢失

参数：

  • v: 要序列化的值（任意类型）

返回值：

  • []byte: 序列化后的字节数组（包含类型信息）
  • error: 如果序列化失败返回错误

示例： 

// 基础类型
data, _ := SerializeAny(42)
result, _ := DeserializeAny(data) // result: 42 (int)

// 复杂类型
type Person struct { Name string; Age int }
data, _ := SerializeAny(Person{Name: "Alice", Age: 30})
result, _ := DeserializeAny(data) // result: map[string]any{"Name": "Alice", "Age": 30.0}

func SetValue 

func SetValue(m map[string]interface{}, keys []string, value interface{}) (bool, error)

SetValue 在 Map 中设置值，支持嵌套路径。

参数:

  • m: 目标 Map
  • keys: 键路径数组（如 []string{"user", "name"}）
  • value: 要设置的值

返回值:

  • bool: 是否成功设置（值相同时返回 false）
  • error: 如果路径中间的键不是 Map 返回错误

用法: 

m := make(map[string]interface{})
ok, err := SetValue(m, []string{"user", "name"}, "John")
// m = {"user": {"name": "John"}}

特点:

  • 自动创建中间的 Map
  • 值相同时返回 false
  • 支持任意深度的嵌套

局限:

  • 如果中间路径已存在非 Map 值会返回错误

func SliceContains 

func SliceContains(slice []string, item string, ignoreCase ...bool) bool

func SliceToAny 

func SliceToAny[T any](s []T) []any

SliceToAny 将类型化的切片转换为 []any。

参数:

  • s: 源切片

返回值:

  • []any: 转换后的 any 切片

用法: 

ints := []int{1, 2, 3}
anys := SliceToAny(ints)  // []any{1, 2, 3}

func ToBool 

func ToBool(value interface{}) bool

ToBool 将值转换为布尔值。

参数:

  • value: 需要转换的值

返回值:

  • bool: 转换后的布尔值

用法: 

b := ToBool("true")         // true
b := ToBool(1)              // true
b := ToBool(0)              // false

func ToBoolE 

func ToBoolE(value interface{}) (bool, error)

ToBoolE 将值转换为布尔值，返回错误。

参数:

  • value: 需要转换的值

返回值:

  • bool: 转换后的布尔值
  • error: 如果转换失败返回错误

func ToFloat64 

func ToFloat64(value interface{}) float64

ToFloat64 将值转换为浮点数。

参数:

  • value: 需要转换的值

返回值:

  • float64: 转换后的浮点数

用法: 

f := ToFloat64("3.14")      // 3.14
f := ToFloat64(3)           // 3.0

func ToFloat64E 

func ToFloat64E(value interface{}) (float64, error)

ToFloat64E 将值转换为浮点数，返回错误。

参数:

  • value: 需要转换的值

返回值:

  • float64: 转换后的浮点数
  • error: 如果转换失败返回错误

func ToInt 

func ToInt(value interface{}) int

ToInt 将值转换为整数。

参数:

  • value: 需要转换的值

返回值:

  • int: 转换后的整数

用法: 

num := ToInt("123")         // 123
num := ToInt(3.14)          // 3
num := ToInt(true)          // 1

局限:

  • 转换失败时返回 0
  • 浮点数会被截断

func ToInt64 

func ToInt64(value interface{}) int64

ToInt64 将值转换为 int64。

参数:

  • value: 需要转换的值

返回值:

  • int64: 转换后的 int64

用法: 

num := ToInt64("9223372036854775807")

func ToInt64E 

func ToInt64E(value interface{}) (int64, error)

ToInt64E 将值转换为 int64，返回错误。

参数:

  • value: 需要转换的值

返回值:

  • int64: 转换后的 int64
  • error: 如果转换失败返回错误

func ToIntE 

func ToIntE(value interface{}) (int, error)

ToIntE 将值转换为整数，返回错误。

参数:

  • value: 需要转换的值

返回值:

  • int: 转换后的整数
  • error: 如果转换失败返回错误

用法: 

num, err := ToIntE("123")
num, err := ToIntE("invalid")  // 返回错误

func ToJson 

func ToJson[T any](d T) string

func ToJson2 

func ToJson2[T any](d T) json.RawMessage

func ToJson2E 

func ToJson2E[T any](d T) (json.RawMessage, error)

func ToJsonE 

func ToJsonE[T any](d T) (string, error)

func ToStr 

func ToStr(value any) string

ToStr 将值转换为字符串。

参数:

  • value: 需要转换的值

返回值:

  • string: 转换后的字符串

用法: 

str := ToStr(123)           // "123"
str := ToStr(3.14)          // "3.14"
str := ToStr(true)          // "true"
str := ToStr(nil)           // ""

局限:

  • Map、Slice、Struct 会转换为 JSON 字符串
  • 转换失败时返回 fmt.Sprintf 的结果

func ToStrE 

func ToStrE(value interface{}) (string, error)

ToStrE 将值转换为字符串，返回错误。

参数:

  • value: 需要转换的值

返回值:

  • string: 转换后的字符串
  • error: 如果转换失败返回错误

func ToTime 

func ToTime(value interface{}) time.Time

ToTime 将值转换为 time.Time。

参数:

  • value: 需要转换的值，支持多种格式

返回值:

  • time.Time: 转换后的时间对象

用法: 

t1 := ToTime("2024-01-15")                    // 日期字符串
t2 := ToTime("2024-01-15 10:30:45")           // 日期时间字符串
t3 := ToTime(int64(1700000000))               // Unix 时间戳（秒）
t4 := ToTime(float64(1700000000.123))         // Unix 时间戳（浮点数）
t5 := ToTime(1700000000)                      // Unix 时间戳（整数）
t6 := ToTime(time.Now())                      // 已是 time.Time

支持的格式:

  • time.Time: 直接返回
  • 整数/浮点数: 作为 Unix 时间戳（秒数）
  • 字符串: 尝试多种时间格式解析
  • RFC3339: "2024-01-15T10:30:45Z"
  • RFC3339Nano: "2024-01-15T10:30:45.123456Z"
  • 日期时间: "2024-01-15 10:30:45"
  • 日期: "2024-01-15"
  • 时间: "10:30:45"

特点:

  • 支持多种时间格式自动识别
  • 支持 Unix 时间戳（秒、毫秒、微秒、纳秒）
  • 支持浮点数时间戳（自动识别精度）
  • 转换失败时返回零值时间

局限:

  • 字符串格式不匹配时返回零值
  • 无法识别的格式返回零值

func ToTimeE 

func ToTimeE(value interface{}) (time.Time, error)

ToTimeE 将值转换为 time.Time，返回错误。

参数:

  • value: 需要转换的值，支持多种格式

返回值:

  • time.Time: 转换后的时间对象
  • error: 如果转换失败返回错误

用法: 

t, err := ToTimeE("2024-01-15")
if err != nil {
    log.Fatal(err)
}

支持的格式:

  • time.Time: 直接返回
  • 整数/浮点数: 作为 Unix 时间戳
  • int/int32/int64: 秒数
  • float32/float64: 秒数（支持小数）
  • 字符串: 尝试多种时间格式解析
  • RFC3339: "2024-01-15T10:30:45Z"
  • RFC3339Nano: "2024-01-15T10:30:45.123456Z"
  • 日期时间: "2024-01-15 10:30:45"
  • 日期: "2024-01-15"
  • 时间: "10:30:45"

特点:

  • 支持多种时间格式自动识别
  • 支持 Unix 时间戳（秒、毫秒、微秒、纳秒）
  • 支持浮点数时间戳（自动识别精度）
  • 详细的错误信息

局限:

  • 字符串格式不匹配时返回错误
  • 无法识别的格式返回错误

Types

type MultiLineString 

type MultiLineString string

func (MultiLineString) MarshalJSON 

func (s MultiLineString) MarshalJSON() ([]byte, error)

func (MultiLineString) MarshalYAML 

func (s MultiLineString) MarshalYAML() (interface{}, error)

func (*MultiLineString) UnmarshalJSON 

func (s *MultiLineString) UnmarshalJSON(data []byte) error

func (*MultiLineString) UnmarshalYAML 

func (s *MultiLineString) UnmarshalYAML(value *yaml.Node) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.