Help us shape the future of Go! Take the 2026 Go Developer Survey

cytype

package
v1.2.1 Latest Latest
Warning

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

 Go to latest Published: Sep 11, 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.