泛型类

package
v0.0.0-...-2910145 Latest Latest
Warning

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

 Go to latest Published: Feb 14, 2024 License: MIT Imports: 8 Imported by: 0

Documentation

Overview

包gvar提供了一种通用变量类型，类似于泛型。

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MapOption 

type MapOption = 转换类.MapOption

MapOption 定义了映射转换的选项。

type Var 

type Var struct {
	// contains filtered or unexported fields
}

Var 是一个通用变量类型的实现者。

func X创建 

func X创建(值 interface{}, 并发安全 ...bool) *Var

New 函数用于创建并返回一个具有给定 `value` 的新 Var。 可选参数 `safe` 指定了 Var 是否在并发安全环境下使用，默认为 false。

func (*Var) Array别名 

func (v *Var) Array别名() []interface{}

Array 是 Interfaces 的别名。

func (*Var) DeepCopy 

func (v *Var) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (*Var) Interface 

func (v *Var) Interface() interface{}

Interface 是 Val 的别名。

Example

Interface 

var v = 泛型类.X创建(100.00)
g.X调试输出并带类型(v.Interface())

Output:

float64(100)

func (*Var) MapDeep弃用 

func (v *Var) MapDeep弃用(值类型标签 ...string) map[string]interface{}

MapDeep 递归地将 `v` 转换并返回为 map[string]interface{} 类型的值。 注意：已弃用，请改用 Map。

func (*Var) MapStrStrDeep弃用 

func (v *Var) MapStrStrDeep弃用(值类型标签 ...string) map[string]string

MapStrStrDeep 递归地将 `v` 转换并返回为 map[string]string 类型。 已弃用：请改用 MapStrStr。

func (*Var) MapToMap 

func (v *Var) MapToMap(pointer interface{}, mapping ...map[string]string) (err error)

MapToMap 将任意类型map变量 `params` 转换为另一种map类型变量 `pointer`。 参见 gconv.MapToMap。

Example

MapToMap 

var (
	m1 = 泛型类.X创建(g.MapIntInt{0: 100, 1: 200})
	m2 = g.MapStrStr{}
)

err := m1.MapToMap(&m2)
if err != nil {
	panic(err)
}

fmt.Printf("%#v", m2)

Output:

map[string]string{"0":"100", "1":"200"}

func (*Var) MapToMaps 

func (v *Var) MapToMaps(pointer interface{}, mapping ...map[string]string) (err error)

MapToMaps 将任意类型map变量 `params` 转换为另一种map类型变量 `pointer`。 参见 gconv.MapToMaps。

Example

MapToMaps 

var (
	p1 = g.MapStrAny{"product": g.Map{"id": 1, "price": 100}}
	p2 = g.MapStrAny{"product": g.Map{"id": 2, "price": 200}}
	v  = 泛型类.X创建(g.MapStrAny数组{p1, p2})
	v2 []g.MapStrStr
)

err := v.MapToMaps(&v2)
if err != nil {
	panic(err)
}
fmt.Printf("%#v", v2)

Output:

[]map[string]string{map[string]string{"product":"{\"id\":1,\"price\":100}"}, map[string]string{"product":"{\"id\":2,\"price\":200}"}}

func (*Var) MapToMapsDeep 

func (v *Var) MapToMapsDeep(pointer interface{}, mapping ...map[string]string) (err error)

MapToMapsDeep 将任意类型的 map 变量 `params` 递归地转换为另一种 map 类型变量 `pointer`。 参见 gconv.MapToMapsDeep。

Example

MapToMapsDeep 

var (
	p1 = g.MapStrAny{"product": g.Map{"id": 1, "price": 100}}
	p2 = g.MapStrAny{"product": g.Map{"id": 2, "price": 200}}
	v  = 泛型类.X创建(g.MapStrAny数组{p1, p2})
	v2 []g.MapStrStr
)

err := v.MapToMapsDeep(&v2)
if err != nil {
	panic(err)
}
fmt.Printf("%#v", v2)

Output:

[]map[string]string{map[string]string{"product":"{\"id\":1,\"price\":100}"}, map[string]string{"product":"{\"id\":2,\"price\":200}"}}

func (*Var) MapsDeep弃用 

func (v *Var) MapsDeep弃用(值类型标签 ...string) []map[string]interface{}

MapsDeep 递归地将 `value` 转换为 []map[string]interface{} 类型的切片。 注：已弃用，请改用 Maps。

func (Var) MarshalJSON 

func (v Var) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。

Example

MarshalJSON 

testMap := g.Map{
	"code":  "0001",
	"name":  "Golang",
	"count": 10,
}

var v = 泛型类.X创建(testMap)
res, err := json.Marshal(&v)
if err != nil {
	panic(err)
}
g.X调试输出并带类型(res)

Output:

[]byte(42) "{"code":"0001","count":10,"name":"Golang"}"

func (*Var) Slice别名 

func (v *Var) Slice别名() []interface{}

Slice 是 Interfaces 的别名。

func (*Var) String 

func (v *Var) String() string

String将`v`转换并以字符串形式返回。

Example

String 

var v = 泛型类.X创建("GoFrame")
g.X调试输出并带类型(v.String())

Output:

string(7) "GoFrame"

func (*Var) Struct 

func (v *Var) Struct(pointer interface{}, mapping ...map[string]string) error

Struct 将 `v` 的值映射到 `pointer`。 参数 `pointer` 应该是指向结构体实例的指针。 参数 `mapping` 用于指定键到属性的映射规则。

Example 
params1 := g.Map{
	"uid":  1,
	"Name": "john",
}
v := 泛型类.X创建(params1)
type tartget struct {
	Uid  int
	Name string
}
t := new(tartget)
if err := v.Struct(&t); err != nil {
	panic(err)
}
g.X调试输出(t)

Output:

{
    Uid:  1,
    Name: "john",
}

func (*Var) Structs 

func (v *Var) Structs(pointer interface{}, mapping ...map[string]string) error

Structs 将 `v` 转换并以给定的结构体切片形式返回。

Example 
paramsArray := []g.Map{}
params1 := g.Map{
	"uid":  1,
	"Name": "golang",
}
params2 := g.Map{
	"uid":  2,
	"Name": "java",
}

paramsArray = append(paramsArray, params1, params2)
v := 泛型类.X创建(paramsArray)
type tartget struct {
	Uid  int
	Name string
}
var t []tartget
if err := v.Structs(&t); err != nil {
	panic(err)
}
g.X调试输出并带类型(t)

Output:

[]泛型类_test.tartget(2) [
    泛型类_test.tartget(2) {
        Uid:  int(1),
        Name: string(6) "golang",
    },
    泛型类_test.tartget(2) {
        Uid:  int(2),
        Name: string(4) "java",
    },
]

func (*Var) UnmarshalJSON 

func (v *Var) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

Example

UnmarshalJSON 

tmp := []byte(`{
	     "Code":          "0003",
	     "Name":          "Golang Book3",
	     "Quantity":      3000,
	     "Price":         300,
	     "OnSale":        true
	}`)
var v = 泛型类.X创建(map[string]interface{}{})
if err := json.Unmarshal(tmp, &v); err != nil {
	panic(err)
}

g.X调试输出(v)

Output:

"{\"Code\":\"0003\",\"Name\":\"Golang Book3\",\"OnSale\":true,\"Price\":300,\"Quantity\":3000}"

func (*Var) UnmarshalValue 

func (v *Var) UnmarshalValue(value interface{}) error

UnmarshalValue 是一个接口实现，用于为 Var 设置任意类型的值。

Example

UnmarshalValue 

tmp := g.Map{
	"code":  "00002",
	"name":  "GoFrame",
	"price": 100,
	"sale":  true,
}

var v = 泛型类.X创建(map[string]interface{}{})
if err := v.UnmarshalValue(tmp); err != nil {
	panic(err)
}
g.X调试输出(v)

Output:

"{\"code\":\"00002\",\"name\":\"GoFrame\",\"price\":100,\"sale\":true}"

func (*Var) X取Map 

func (v *Var) X取Map(选项 ...MapOption) map[string]interface{}

Map 将 `v` 转换并以 map[string]interface{} 类型返回。

func (*Var) X取MapStrAny 

func (v *Var) X取MapStrAny(选项 ...MapOption) map[string]interface{}

MapStrAny 类似于函数 Map，但实现了 MapStrAny 接口。

func (*Var) X取Map数组 

func (v *Var) X取Map数组(选项 ...MapOption) []map[string]interface{}

Maps 将 `v` 转换并以 map[string]string 类型返回。 参见 gconv.Maps。

func (*Var) X取any数组 

func (v *Var) X取any数组() []interface{}

Interfaces 将 `v` 转换并返回为 []interfaces{} 类型的切片。

func (*Var) X取gtime时间类 

func (v *Var) X取gtime时间类(格式 ...string) *时间类.Time

GTime 将 `v` 转换并返回为 *gtime.Time 类型。 参数 `format` 指定了时间字符串的格式，遵循 gtime 的规则， 例如：Y-m-d H:i:s。

func (*Var) X取值 

func (v *Var) X取值() interface{}

Val 返回当前变量 `v` 的值。

func (*Var) X取字节集 

func (v *Var) X取字节集() []byte

Bytes 将 `v` 转换并返回为 []byte 类型。

func (*Var) X取小数32位 

func (v *Var) X取小数32位() float32

Float32将`v`转换为float32类型并返回。

func (*Var) X取小数32位数组 

func (v *Var) X取小数32位数组() []float32

Float32s 将 `v` 转换并返回为 []float32 类型的切片。

func (*Var) X取小数64位 

func (v *Var) X取小数64位() float64

Float64将`v`转换为float64类型并返回。

func (*Var) X取小数64位数组 

func (v *Var) X取小数64位数组() []float64

Float64s将`v`转换并返回为[]float64类型。

func (*Var) X取小数数组 

func (v *Var) X取小数数组() []float64

Floats 是 Float64s 的别名。

func (*Var) X取布尔 

func (v *Var) X取布尔() bool

Bool将`v`转换并作为布尔值返回。

func (*Var) X取整数 

func (v *Var) X取整数() int

Int 将 `v` 转换并返回为 int 类型。

func (*Var) X取整数16位 

func (v *Var) X取整数16位() int16

Int16将`v`转换并返回为int16类型。

func (*Var) X取整数32位 

func (v *Var) X取整数32位() int32

Int32将`v`转换为int32类型并返回。

func (*Var) X取整数64位 

func (v *Var) X取整数64位() int64

Int64将`v`转换并作为int64类型返回。

func (*Var) X取整数64位数组 

func (v *Var) X取整数64位数组() []int64

Int64s 将 `v` 转换并返回为 []int64 类型的切片。

func (*Var) X取整数8位 

func (v *Var) X取整数8位() int8

Int8将`v`转换并返回为int8类型。

func (*Var) X取整数数组 

func (v *Var) X取整数数组() []int

Ints 将 `v` 转换并返回为 []int 类型的切片。

func (*Var) X取文本Map 

func (v *Var) X取文本Map(选项 ...MapOption) map[string]string

MapStrStr将`v`转换并返回为map[string]string类型。

func (*Var) X取文本数组 

func (v *Var) X取文本数组() []string

Strings 将 `v` 转换并返回为 []string 类型。

func (*Var) X取时长 

func (v *Var) X取时长() time.Duration

Duration 将 `v` 转换并返回为 time.Duration 类型。 如果 `v` 的值为字符串，那么它将使用 time.ParseDuration 进行转换。

func (*Var) X取时间类 

func (v *Var) X取时间类(格式 ...string) time.Time

Time将`v`转换并返回为time.Time类型。 参数`format`用于指定时间字符串的格式，采用gtime格式规范， 例如：Y-m-d H:i:s。

func (*Var) X取正整数 

func (v *Var) X取正整数() uint

Uint将`v`转换并作为uint类型返回。

func (*Var) X取正整数16位 

func (v *Var) X取正整数16位() uint16

Uint16将`v`转换并作为uint16类型返回。

func (*Var) X取正整数32位 

func (v *Var) X取正整数32位() uint32

Uint32将`v`转换并作为uint32类型返回。

func (*Var) X取正整数64位 

func (v *Var) X取正整数64位() uint64

Uint64将`v`转换并作为uint64类型返回。

func (*Var) X取正整数64位数组 

func (v *Var) X取正整数64位数组() []uint64

Uint64s将`v`转换并返回为[]uint64类型。

func (*Var) X取正整数8位 

func (v *Var) X取正整数8位() uint8

Uint8将`v`转换并作为uint8类型返回。

func (*Var) X取正整数数组 

func (v *Var) X取正整数数组() []uint

Uints 将 `v` 转换并返回为 []uint 类型。

func (*Var) X取泛型类Map 

func (v *Var) X取泛型类Map(选项 ...MapOption) map[string]*Var

MapStrVar 将 `v` 转换并返回为 map[string]Var 类型。

func (*Var) X取泛型类Map_递归 

func (v *Var) X取泛型类Map_递归(值类型标签 ...string) map[string]*Var

MapStrVarDeep 递归地将 `v` 转换并返回为 map[string]*Var 类型的值。 已弃用：请改用 MapStrVar。

func (*Var) X取泛型类数组 

func (v *Var) X取泛型类数组() []*Var

Vars 将 `v` 转换并返回为 []Var 类型的切片。

func (*Var) X取结构体指针 

func (v *Var) X取结构体指针(结构体指针 interface{}, 名称映射 ...map[string]string) error

Scan 会自动检测 `pointer` 的类型，并将 `params` 转换为 `pointer`。它支持对 `pointer` 进行转换的类型包括：`*map`、`*[]map`、`*[]*map`、`*struct`、`**struct`、`*[]struct` 和 `*[]*struct`。

详情请参阅 gconv.Scan。

func (*Var) X取结构数组或Map数组值 

func (v *Var) X取结构数组或Map数组值(名称 interface{}) (值s []interface{})

ListItemValues 通过 key `key` 获取并返回所有项（item）结构体或映射中的元素。 注意，参数 `list` 应为包含映射或结构体元素的切片类型， 否则将返回一个空切片。

func (*Var) X取结构数组或Map数组值并去重 

func (v *Var) X取结构数组或Map数组值并去重(名称 string) []interface{}

ListItemValuesUnique 通过键 `key` 获取并返回所有结构体或映射中的唯一元素。 注意，参数 `list` 应为包含映射或结构体元素的切片类型， 否则将返回一个空切片。

func (*Var) X是否为Map 

func (v *Var) X是否为Map() bool

IsMap 检查 `v` 是否为 map 类型。

func (*Var) X是否为Nil 

func (v *Var) X是否为Nil() bool

IsNil 检查 `v` 是否为 nil。

func (*Var) X是否为小数 

func (v *Var) X是否为小数() bool

IsFloat 检查 `v` 是否为浮点类型。

func (*Var) X是否为数组 

func (v *Var) X是否为数组() bool

IsSlice 检查 `v` 是否为切片类型。

func (*Var) X是否为整数 

func (v *Var) X是否为整数() bool

IsInt 检查 `v` 是否为 int 类型。

func (*Var) X是否为正整数 

func (v *Var) X是否为正整数() bool

IsUint 检查 `v` 是否为 uint 类型。

func (*Var) X是否为空 

func (v *Var) X是否为空() bool

IsEmpty 检查 `v` 是否为空。

func (*Var) X是否为结构 

func (v *Var) X是否为结构() bool

IsStruct 检查 `v` 是否为结构体类型。

func (*Var) X浅拷贝 

func (v *Var) X浅拷贝() *Var

Clone 执行当前 Var 的浅复制，并返回指向此 Var 的指针。

func (*Var) X深拷贝 

func (v *Var) X深拷贝() *Var

Copy 对当前 Var 进行深度复制，并返回指向新复制得到的 Var 的指针。

func (*Var) X设置值 

func (v *Var) X设置值(值 interface{}) (旧值 interface{})

Set将`value`设置为`v`，并返回旧的值。

type Vars 

type Vars []*Var

Vars 是一个 *Var 类型的切片。

func (Vars) X取any数组 

func (vs Vars) X取any数组() (数组 []interface{})

Interfaces将`vs`转换并返回为[]interface{}类型。

func (Vars) X取小数32位数组 

func (vs Vars) X取小数32位数组() (数组 []float32)

Float32s将`vs`转换并返回为[]float32类型。

func (Vars) X取小数64位数组 

func (vs Vars) X取小数64位数组() (数组 []float64)

Float64s 将 `vs` 转换并返回为 []float64 类型的切片。

func (Vars) X取整数16位数组 

func (vs Vars) X取整数16位数组() (数组 []int16)

Int16s将`vs`转换并返回为[]int16类型。

func (Vars) X取整数32位数组 

func (vs Vars) X取整数32位数组() (数组 []int32)

Int32s 将 `vs` 转换并返回为 []int32 类型的切片。

func (Vars) X取整数64位数组 

func (vs Vars) X取整数64位数组() (数组 []int64)

Int64s将`vs`转换并返回为[]int64类型。

func (Vars) X取整数8位数组 

func (vs Vars) X取整数8位数组() (数组 []int8)

Int8s将`vs`转换并返回为[]int8类型。

func (Vars) X取整数数组 

func (vs Vars) X取整数数组() (数组 []int)

Ints将`vs`转换并返回为[]Int类型。

func (Vars) X取文本数组 

func (vs Vars) X取文本数组() (数组 []string)

Strings 将 `vs` 转换并返回为 []string 类型的切片。

func (Vars) X取正整数16位数组 

func (vs Vars) X取正整数16位数组() (数组 []uint16)

Uint16s 将 `vs` 转换并返回为 []uint16 类型的切片。

func (Vars) X取正整数32位数组 

func (vs Vars) X取正整数32位数组() (数组 []uint32)

Uint32s 将 `vs` 转换并返回为 []uint32 类型的切片。

func (Vars) X取正整数64位数组 

func (vs Vars) X取正整数64位数组() (数组 []uint64)

Uint64s 将 `vs` 转换并返回为 []uint64 类型的切片。

func (Vars) X取正整数8位数组 

func (vs Vars) X取正整数8位数组() (数组 []uint8)

Uint8s将`vs`转换并返回为[]uint8类型。

func (Vars) X取正整数数组 

func (vs Vars) X取正整数数组() (数组 []uint)

Uints 将 `vs` 转换并返回为 []uint 类型的切片。

func (Vars) X取结构体指针 

func (vs Vars) X取结构体指针(结构体指针 interface{}, 名称映射 ...map[string]string) error

Scan 将 `vs` 转换为 []struct 或 []*struct 类型的切片。

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.