泛型类型-gvar - 泛型类型-方法介绍 - 《GoFrame v2.4 开发文档》

**New**
Create
Clone
Set
Val
Interface
Bytes
String
Bool
Int
Uint
Float32
Float64
Time
GTime
Duration
MarshalJSON
UnmarshalJSON
UnmarshalValue
IsNil
IsEmpty
IsInt
IsUint
IsFloat
IsSlice
IsMap
IsStruct
ListItemValues
ListItemValuesUnique
Struct
Structs
Ints
Int64s
Uints
Uint64s
Floats
Float64s
Float32s
Strings
Interfaces
Slice
Array
Vars
Map
MapStrAny
MapStrStr
MapStrVar
MapDeep
MapStrStrDeep
MapStrVarDeep
Maps
MapsDeep
MapToMap
MapToMaps
MapToMapsDeep
Scan

以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档：https://pkg.go.dev/github.com/gogf/gf/v2/container/gvar

`New`

说明：New 创建并返回一个带有给定value的新 Var。可选参数 safe指定是否在并发安全中使用 Var,其默认值是false。

格式：

func New(value interface{}, safe ...bool) *Var

示例：

// New
func ExampleVarNew() {
   v := gvar.New(400)
   g.Dump(v)
   // Output:
   // "400"
}

`Create`

说明：Create创建并返回一个带有给定v的新 Var。可选参数 safe指定是否在并发安全中使用 Var,其默认值是false。

格式：

func Create(value interface{}, safe ...bool) Var

示例：

// Create
func ExampleVarCreate() {
    var v = gvar.Create(100.0)
    g.Dump(&v)
    // Output:
    // "100"
}

`Clone`

说明：Clone将当前 Var 的浅拷贝并返回一个指向此 Var 的指针。
格式：
```
func (v *Var) Clone() *Var
```

示例

// Clone
func ExampleVar_Clone() {
    tmp := "fisrt hello"
    v := gvar.New(tmp)
    g.DumpWithType(v.Clone())
    fmt.Println(v == v.Clone())
    // Output:
    // *gvar.Var(11) "fisrt hello"
    // false
}

`Set`

说明：Set 将v的值设置为value并返回v的旧值。

格式：

func (v *Var) Set(value interface{}) (old interface{})

示例：

// Set
func ExampleVar_Set() {
    var v = gvar.New(100.00)
    g.Dump(v.Set(200.00))
    g.Dump(v)
    // Output:
    // 100
    // "200"
}

`Val`

说明：Val 返回v的当前值，类型为interface{}。
格式：
```
func (v *Var) Val() interface{}
```

示例：

// Val
func ExampleVar_Val() {
    var v = gvar.New(100.00)
    g.DumpWithType(v.Val())
    // Output:
    // float64(100)
}

`Interface`

说明：Interface 是Val的别名。
格式：
```
func (v *Var) Interface() interface{}
```

示例：

// Interface
func ExampleVar_Interface() {
    var v = gvar.New(100.00)
    g.DumpWithType(v.Interface())
    // Output:
    // float64(100)
}

`Bytes`

说明：Bytes将v转换为字节数组。
格式：
```
func (v *Var) Bytes() []byte
```

示例：

// Bytes
func ExampleVar_Bytes() {
    var v = gvar.New("GoFrame")
    g.DumpWithType(v.Bytes())
    // Output:
    // []byte(7) "GoFrame"
}

`String`

说明：String将v转换为字符串。
格式：
```
func (v *Var) String() string
```

示例：

// String
func ExampleVar_String() {
    var v = gvar.New("GoFrame")
    g.DumpWithType(v.String())
    // Output:
    // string(7) "GoFrame"
}

`Bool`

说明：Bool将v转换为布尔值。
格式：
```
func (v *Var) Bool() bool
```

示例：

// Bool
func ExampleVar_Bool() {
    var v = gvar.New(true)
    g.DumpWithType(v.Bool())
    // Output:
    // bool(true)
}

`Int`

说明：Int将v转换为整型。
格式：
```
func (v *Var) Int() int
```

示例：

// Int
func ExampleVar_Int() {
    var v = gvar.New(-1000)
    g.DumpWithType(v.Int())
    // Output:
    // int(-1000)
}

`Uint`

说明：Uint将v转换为无符号整型。
格式：
```
func (v *Var) Uint() uint
```

示例：

// Uint
func ExampleVar_Uint() {
    var v = gvar.New(1000)
    g.DumpWithType(v.Uint())
    // Output:
    // uint(1000)
}

`Float32`

说明：Float32将v转换为32位浮点型。
格式：
```
func (v *Var) Float32() float32
```

示例：

// Float32
func ExampleVar_Float32() {
    var price = gvar.New(100.00)
    g.DumpWithType(price.Float32())
    // Output:
    // float32(100)
}

`Float64`

说明：Float64将v转换为64位浮点型。
格式：
```
func (v *Var) Float64() float64
```

示例：

// Float32
func ExampleVar_Float64() {
    var price = gvar.New(100.00)
    g.DumpWithType(price.Float64())
    // Output:
    // float64(100)
}

`Time`

说明：Time将v转换为time.Time。参数format用 gtime 指定时间字符串的格式，例如：Y-m-d H:i:s。

格式：

func (v *Var) Time(format ...string) time.Time

示例：

// Time
func ExampleVar_Time() {
    var v = gvar.New("2021-11-11 00:00:00")
    g.DumpWithType(v.Time())
    // Output:
    // time.Time(29) "2021-11-11 00:00:00 +0800 CST"
}

`GTime`

说明：G``Time将v转换为*gtime.Time。参数format用gtime 指定时间字符串的格式，例如：Y-m-d H:i:s。

格式：

func (v *Var) GTime(format ...string) *gtime.Time

示例：

// GTime
func ExampleVar_GTime() {
    var v = gvar.New("2021-11-11 00:00:00")
    g.DumpWithType(v.GTime())
    // Output:
    // *gtime.Time(19) "2021-11-11 00:00:00"
}

`Duration`

说明：Duration将v转换为time.Duration。如果v的值是字符串，那么它使用 time.ParseDuration 进行转换。
格式：
```
func (v *Var) Duration() time.Duration
```

示例：

// Duration
func ExampleVar_Duration() {
    var v = gvar.New("300s")
    g.DumpWithType(v.Duration())
    // Output:
    // time.Duration(4) "5m0s"
}

`MarshalJSON`

说明：MarshalJSON 实现了json接口的MarshalJSON。

格式：

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

示例：

// MarshalJSON
func ExampleVar_MarshalJSON() {
    testMap := g.Map{
        "code":  "0001",
        "name":  "Golang",
        "count": 10,
    }
    var v = gvar.New(testMap)
    res, err := json.Marshal(&v)
    if err != nil {
        panic(err)
    }
    g.DumpWithType(res)
    // Output:
    // []byte(42) "{"code":"0001","count":10,"name":"Golang"}"
}

`UnmarshalJSON`

说明： UnmarshalJSON 实现了json接口的 UnmarshalJSON。

格式：

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

示例：

// UnmarshalJSON
func ExampleVar_UnmarshalJSON() {
    tmp := []byte(`{
         "Code":          "0003",
         "Name":          "Golang Book3",
         "Quantity":      3000,
         "Price":         300,
         "OnSale":        true
    }`)
    var v = gvar.New(map[string]interface{}{})
    if err := json.Unmarshal(tmp, &v); err != nil {
        panic(err)
    }
    g.Dump(v)
    // Output:
    // "{\"Code\":\"0003\",\"Name\":\"Golang Book3\",\"OnSale\":true,\"Price\":300,\"Quantity\":3000}"
}

`UnmarshalValue`

说明： UnmarshalValue 是一个接口实现，它为 Var设置任何类型的值。

格式：

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

示例：

// UnmarshalValue
func ExampleVar_UnmarshalValue() {
    tmp := g.Map{
        "code":  "00002",
        "name":  "GoFrame",
        "price": 100,
        "sale":  true,
    }
    var v = gvar.New(map[string]interface{}{})
    if err := v.UnmarshalValue(tmp); err != nil {
        panic(err)
    }
    g.Dump(v)
    // Output:
    // "{\"code\":\"00002\",\"name\":\"GoFrame\",\"price\":100,\"sale\":true}"
}

`IsNil`

说明： IsNil判断v是否为nil，为nil返回true，反之返回false。
格式：
```
func (v *Var) IsNil() bool
```

示例：

/// IsNil
func ExampleVar_IsNil() {
    g.Dump(gvar.New(0).IsNil())
    g.Dump(gvar.New(0.1).IsNil())
    // true
    g.Dump(gvar.New(nil).IsNil())
    g.Dump(gvar.New("").IsNil())
    // Output:
    // false
    // false
    // true
    // false
}

`IsEmpty`

说明： IsEmpty判断v是否为空，为空返回true，反之返回false。
格式：
```
func (v *Var) IsEmpty() bool
```

示例：

// IsEmpty
func ExampleVar_IsEmpty() {
    g.Dump(gvar.New(0).IsEmpty())
    g.Dump(gvar.New(nil).IsEmpty())
    g.Dump(gvar.New("").IsEmpty())
    g.Dump(gvar.New(g.Map{"k": "v"}).IsEmpty())
    // Output:
    // true
    // true
    // true
    // false
}

`IsInt`

说明： IsInt判断v是否为int类型，如果是int类型返回true，反之返回false。
格式：
```
func (v *Var) IsInt() bool
```

示例：

// IsInt
func ExampleVar_IsInt() {
    g.Dump(gvar.New(0).IsInt())
    g.Dump(gvar.New(0.1).IsInt())
    g.Dump(gvar.New(nil).IsInt())
    g.Dump(gvar.New("").IsInt())
    // Output:
    // true
    // false
    // false
    // false
}

`IsUint`

说明： IsUint判断v是否为uint类型，如果是uint类型返回true，反之返回false。
格式：
```
func (v *Var) IsUint() bool
```

示例：

// IsUint
func ExampleVar_IsUint() {
    g.Dump(gvar.New(0).IsUint())
    g.Dump(gvar.New(uint8(8)).IsUint())
    g.Dump(gvar.New(nil).IsUint())
    // Output:
    // false
    // true
    // false
}

`IsFloat`

说明： IsFloat判断v是否为float类型，如果是float类型返回true，反之返回false。
格式：
```
func (v *Var) IsFloat() bool
```

示例：

// IsFloat
func ExampleVar_IsFloat() {
    g.Dump(g.NewVar(uint8(8)).IsFloat())
    g.Dump(g.NewVar(float64(8)).IsFloat())
    g.Dump(g.NewVar(0.1).IsFloat())
    // Output:
    // false
    // true
    // true
}

`IsSlice`

说明： IsSlice判断v是否为切片类型，如果是slice类型返回true，反之返回false。
格式：
```
func (v *Var) IsSlice() bool
```

示例：

// IsSlice
func ExampleVar_IsSlice() {
    g.Dump(g.NewVar(0).IsSlice())
    g.Dump(g.NewVar(g.Slice{0}).IsSlice())
    // Output:
    // false
    // true
}

`IsMap`

说明： IsMap判断v是否为映射类型，如果是map类型返回true，反之返回false。
格式：
```
func (v *Var) IsMap() bool
```

示例：

// IsMap
func ExampleVar_IsMap() {
    g.Dump(g.NewVar(0).IsMap())
    g.Dump(g.NewVar(g.Map{"k": "v"}).IsMap())
    g.Dump(g.NewVar(g.Slice{}).IsMap())
    // Output:
    // false
    // true
    // false
}

`IsStruct`

说明： IsStruct判断v是否为结构体类型，如果是struct类型返回true，反之返回false。
格式：
```
func (v *Var) IsStruct() bool
```

示例：

// IsStruct
func ExampleVar_IsStruct() {
    g.Dump(g.NewVar(0).IsStruct())
    g.Dump(g.NewVar(g.Map{"k": "v"}).IsStruct())
    a := struct{}{}
    g.Dump(g.NewVar(a).IsStruct())
    g.Dump(g.NewVar(&a).IsStruct())
    // Output:
    // false
    // false
    // true
    // true
}

`ListItemValues`

说明： ListItemValues 用键key检索并返回所有项结构/映射的元素。注意，参数list应该是切片类型，其中包含 map 或 struct的元素，否则它会返回一个空切片。

格式：

func (v *Var) ListItemValues(key interface{}) (values []interface{})

示例：

// ListItemValues
func ExampleVar_ListItemValues() {
    var goods1 = g.List{
        g.Map{"id": 1, "price": 100.00},
        g.Map{"id": 2, "price": 0},
        g.Map{"id": 3, "price": nil},
    }
    var v = gvar.New(goods1)
    fmt.Println(v.ListItemValues("id"))
    fmt.Println(v.ListItemValues("price"))
    // Output:
    // [1 2 3]
    // [100 0 <nil>]
}

`ListItemValuesUnique`

说明： ListItemValuesUnique 检索并返回所有带有指定key的 struct/map 的唯一元素。注意，参数list应该是切片类型，其中包含 map 或 struct 的元素，否则它会返回一个空切片。

格式：

func (v *Var) ListItemValuesUnique(key string) []interface{}

示例：

// ListItemValuesUnique
func ExampleVar_ListItemValuesUnique() {
    var (
        goods1 = g.List{
            g.Map{"id": 1, "price": 100.00},
            g.Map{"id": 2, "price": 100.00},
            g.Map{"id": 3, "price": nil},
        }
        v = gvar.New(goods1)
    )
    fmt.Println(v.ListItemValuesUnique("id"))
    fmt.Println(v.ListItemValuesUnique("price"))
    // Output:
    // [1 2 3]
    // [100 <nil>]
}

`Struct`

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

格式：

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

示例：

func ExampleVar_Struct() {
    params1 := g.Map{
        "uid":  1,
        "Name": "john",
    }
    v := gvar.New(params1)
    type tartget struct {
        Uid  int
        Name string
    }
    t := new(tartget)
    if err := v.Struct(&t); err != nil {
        panic(err)
    }
    g.Dump(t)
    // Output:
    // {
    //     Uid:  1,
    //     Name: "john",
    // }
}

`Structs`

说明： Structs 将v转换为给定结构体的切片类型。参数pointer应该是指向结构体实例的指针。参数mapping用于指定键到属性的映射规则。

格式：

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

示例：

func ExampleVar_Structs() {
    paramsArray := []g.Map{}
    params1 := g.Map{
        "uid":  1,
        "Name": "golang",
    }
    params2 := g.Map{
        "uid":  2,
        "Name": "java",
    }
    paramsArray = append(paramsArray, params1, params2)
    v := gvar.New(paramsArray)
    type tartget struct {
        Uid  int
        Name string
    }
    var t []tartget
    if err := v.Structs(&t); err != nil {
        panic(err)
    }
    g.DumpWithType(t)
    // Output:
    // []gvar_test.tartget(2) [
    //     gvar_test.tartget(2) {
    //         Uid:  int(1),
    //         Name: string(6) "golang",
    //     },
    //     gvar_test.tartget(2) {
    //         Uid:  int(2),
    //         Name: string(4) "java",
    //     },
    // ]
}

`Ints`

说明： Ints 将v转换为 []int。
格式：
```
func (v *Var) Ints() []int
```

示例：

// Ints
func ExampleVar_Ints() {
    var (
        arr = []int{1, 2, 3, 4, 5}
        obj = gvar.New(arr)
    )
    fmt.Println(obj.Ints())
    // Output:
    // [1 2 3 4 5]
}

`Int64s`

说明： Int64s 将v转换为 []64int。
格式：
```
func (v *Var) Int64s() []64int
```

示例：

// Int64s
func ExampleVar_Int64s() {
    var (
        arr = []int64{1, 2, 3, 4, 5}
        obj = gvar.New(arr)
    )
    fmt.Println(obj.Int64s())
    // Output:
    // [1 2 3 4 5]
}

`Uints`

说明：Uints 将v转换为 []uint 。
格式：
```
func (v *Var) Uints() []uint
```

示例：

// Uints
func ExampleVar_Uints() {
    var (
        arr = []uint{1, 2, 3, 4, 5}
        obj = gvar.New(arr)
    )
    fmt.Println(obj.Uints())
    // Output:
    // [1 2 3 4 5]
}

`Uint64s`

说明：Uint64s 将v转换为 []uint64 。
格式：
```
func (v *Var) Uint64s() []uint64
```

示例：

// Uint64s
func ExampleVar_Uint64s() {
    var (
        arr = []uint64{1, 2, 3, 4, 5}
        obj = gvar.New(arr)
    )
    fmt.Println(obj.Uint64s())
    // Output:
    // [1 2 3 4 5]
}

`Floats`

说明：Floats Float64s的别名。
格式：
```
func (v *Var) Floats() []float64
```

示例：

// Floats
func ExampleVar_Floats() {
    var (
        arr = []float64{1, 2, 3, 4, 5}
        obj = gvar.New(arr)
    )
    fmt.Println(obj.Floats())
    // Output:
    // [1 2 3 4 5]
}

`Float64s`

说明：Float64s 将v转换为[]float64。
格式：
```
func (v *Var) Float64s() []float64
```

示例：

// Float64s
func ExampleVar_Float64s() {
    var (
        arr = []float64{1, 2, 3, 4, 5}
        obj = gvar.New(arr)
    )
    fmt.Println(obj.Float64s())
    // Output:
    // [1 2 3 4 5]
}

`Float32s`

说明：Float32s 将v转换为[]float32。
格式：
```
func (v *Var) Float32s() []float32
```

示例：

// Float32s
func ExampleVar_Float32s() {
    var (
        arr = []float32{1, 2, 3, 4, 5}
        obj = gvar.New(arr)
    )
    fmt.Println(obj.Float32s())
    // Output:
    // [1 2 3 4 5]
}

`Strings`

说明：Strings 将v转换为[]string。
格式：
```
func (v *Var) Strings() []string
```

示例：

// Strings
func ExampleVar_Strings() {
    var (
        arr = []string{"GoFrame", "Golang"}
        obj = gvar.New(arr)
    )
    fmt.Println(obj.Strings())
    // Output:
    // [GoFrame Golang]
}

`Interfaces`

说明：Interfaces 将v转换为[]interface{}。

格式：

func (v *Var) Interfaces() []interface{}

示例：

// Interfaces
func ExampleVar_Interfaces() {
    var (
        arr = []string{"GoFrame", "Golang"}
        obj = gvar.New(arr)
    )
    fmt.Println(obj.Interfaces())
    // Output:
    // [GoFrame Golang]
}

`Slice`

说明：Slice Interfaces的别名。
格式：
```
func (v *Var) Slice() []interface{}
```

示例：

// Slice
func ExampleVar_Slice() {
    var (
        arr = []string{"GoFrame", "Golang"}
        obj = gvar.New(arr)
    )
    fmt.Println(obj.Slice())
    // Output:
    // [GoFrame Golang]
}

`Array`

说明：Array Interfaces的别名。
格式：
```
func (v *Var) Array() []interface{}
```

示例：

// Array
func ExampleVar_Array() {
    var (
        arr = []string{"GoFrame", "Golang"}
        obj = gvar.New(arr)
    )
    fmt.Println(obj.Array())
    // Output:
    // [GoFrame Golang]
}

`Vars`

说明：Vars 将v转换为[]var。
格式：
```
func (v *Var) Vars() []*Var
```

示例：

// Vars
func ExampleVar_Vars() {
    var (
        arr = []string{"GoFrame", "Golang"}
        obj = gvar.New(arr)
    )
    fmt.Println(obj.Vars())
    // Output:
    // [GoFrame Golang]
}

`Map`

说明：Map 将v转换为map[string]interface{}。

格式：

func (v *Var) Map(tags ...string) map[string]interface{}

示例：

// Map
func ExampleVar_Map() {
    var (
        m   = g.Map{"id": 1, "price": 100.00}
        v   = gvar.New(m)
        res = v.Map()
    )
    fmt.Println(res["id"], res["price"])
    // Output:
    // 1 100
}

`MapStrAny`

说明：MapStrAny 类似于Map函数，但是实现了MapStrAny接口。

格式：

func (v *Var) MapStrAny() map[string]interface{}

示例：

// MapStrAny
func ExampleVar_MapStrAny() {
    var (
        m1 = g.Map{"id": 1, "price": 100}
        v  = gvar.New(m1)
        v2 = v.MapStrAny()
    )
    fmt.Println(v2["price"], v2["id"])
    // Output:
    // 100 1
}

`MapStrStr`

说明：MapStrStr 将v转换为map[string]string。

格式：

func (v *Var) MapStrStr(tags ...string) map[string]string

示例：

// MapStrStr
func ExampleVar_MapStrStr() {
    var (
        m1 = g.Map{"id": 1, "price": 100}
        v  = gvar.New(m1)
        v2 = v.MapStrStr()
    )
    fmt.Println(v2["price"] + "$")
    // Output:
    // 100$
}

`MapStrVar`

说明：MapStrVar 将v转换为map[string]*Var。

格式：

func (v *Var) MapStrVar(tags ...string) map[string]*Var

示例：

// MapStrVar
func ExampleVar_MapStrVar() {
    var (
        m1 = g.Map{"id": 1, "price": 100}
        v  = gvar.New(m1)
        v2 = v.MapStrVar()
    )
    fmt.Println(v2["price"].Float64() * 100)
    // Output:
    // 10000
}

`MapDeep`

说明：MapDeep 将v递归转换为map[string]interface{}。

格式：

func (v *Var) MapDeep(tags ...string) map[string]interface{}

示例：

// MapDeep
func ExampleVar_MapDeep() {
    var (
        m1 = g.Map{"id": 1, "price": 100}
        m2 = g.Map{"product": m1}
        v  = gvar.New(m2)
        v2 = v.MapDeep()
    )
    fmt.Println(v2["product"])
    // Output:
    // map[id:1 price:100]
}

`MapStrStrDeep`

说明：MapStrStrDeep 将v递归转换为map[string]string。

格式：

func (v *Var) MapStrStrDeep(tags ...string) map[string]string

示例：

// MapStrStrDeep
func ExampleVar_MapStrStrDeep() {
    var (
        m1 = g.Map{"id": 1, "price": 100}
        m2 = g.Map{"product": m1}
        v  = gvar.New(m2)
        v2 = v.MapStrStrDeep()
    )
    fmt.Println(v2["product"])
    // Output:
    // {"id":1,"price":100}
}

`MapStrVarDeep`

说明：MapStrVarDeep 将v递归转换为map[string]*Var。

格式：

func (v *Var) MapStrVarDeep(tags ...string) map[string]*Var

示例：

// MapStrVarDeep
func ExampleVar_MapStrVarDeep() {
    var (
        m1 = g.Map{"id": 1, "price": 100}
        m2 = g.Map{"product": m1}
        v  = gvar.New(m2)
        v2 = v.MapStrVarDeep()
    )
    fmt.Println(v2["product"])
    // Output:
    // {"id":1,"price":100}
}

`Maps`

说明：Maps 将v转换为map[string]interface{}。

格式：

func (v *Var) Maps(tags ...string) []map[string]interface{}

示例：

// Maps
func ExampleVar_Maps() {
    var m = gvar.New(g.ListIntInt{g.MapIntInt{0: 100, 1: 200}, g.MapIntInt{0: 300, 1: 400}})
    fmt.Printf("%#v", m.Maps())
    // Output:
    // []map[string]interface {}{map[string]interface {}{"0":100, "1":200}, map[string]interface {}{"0":300, "1":400}}
}

`MapsDeep`

说明：MapsDeep 将v递归转换为[]map[string]interface{}。

格式：

func (v *Var) MapsDeep(tags ...string) []map[string]interface{}

示例：

// MapsDeep
func ExampleVar_MapsDeep() {
    var (
        p1 = g.MapStrAny{"product": g.Map{"id": 1, "price": 100}}
        p2 = g.MapStrAny{"product": g.Map{"id": 2, "price": 200}}
        v  = gvar.New(g.ListStrAny{p1, p2})
        v2 = v.MapsDeep()
    )
    fmt.Printf("%#v", v2)
    // Output:
    // []map[string]interface {}{map[string]interface {}{"product":map[string]interface {}{"id":1, "price":100}}, map[string]interface {}{"product":map[string]interface {}{"id":2, "price":200}}}
}

`MapToMap`

说明：MapToMap 将v转换为pointer指定的map类型，mapping为指定的映射规则。

格式：

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

示例：

// MapToMap
func ExampleVar_MapToMap() {
    var (
        m1 = gvar.New(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"}
}

`MapToMaps`

说明：MapToMaps 将v转换为 pointer 指定的map类型，mapping为指定的映射规则。

格式：

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

示例：

// MapToMaps
func ExampleVar_MapToMaps() {
    var (
        p1 = g.MapStrAny{"product": g.Map{"id": 1, "price": 100}}
        p2 = g.MapStrAny{"product": g.Map{"id": 2, "price": 200}}
        v  = gvar.New(g.ListStrAny{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}"}}
}

`MapToMapsDeep`

说明：MapToMaps 将v递归地转换为pointer 指定的map类型，mapping为指定的映射规则。

格式：

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

示例：

// MapToMapDeep
func ExampleVar_MapToMapDeep() {
    var (
        p1 = gvar.New(g.MapStrAny{"product": g.Map{"id": 1, "price": 100}})
        p2 = g.MapStrAny{}
    )
    err := p1.MapToMap(&p2)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%#v", p2)
    // Output:
    // map[string]interface {}{"product":map[string]interface {}{"id":1, "price":100}}
}

`Scan`

说明：Scan 会自动检查pointer的类型，并将params转换为pointer，pointer支持的类型为：

*map、 *[]map、 *[]*map、 *struct、 **struct、 *[]struct、 *[]*struct

格式：

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

示例：

// Scan
func ExampleVar_Scan() {
    type Student struct {
        Id     *g.Var
        Name   *g.Var
        Scores *g.Var
    }
    var (
        s Student
        m = g.Map{
            "Id":     1,
            "Name":   "john",
            "Scores": []int{100, 99, 98},
        }
    )
    if err := gconv.Scan(m, &s); err != nil {
        panic(err)
    }
    g.DumpWithType(s)
    // Output:
    // gvar_test.Student(3) {
    //     Id:     *gvar.Var(1) "1",
    //     Name:   *gvar.Var(4) "john",
    //     Scores: *gvar.Var(11) "[100,99,98]",
    // }
}

泛型类型-方法介绍

**New**

Create

Clone

Set

Val

Interface

Bytes

String

Bool

Int

Uint

Float32

Float64

Time

GTime

Duration

MarshalJSON

UnmarshalJSON

UnmarshalValue

IsNil

IsEmpty

IsInt

IsUint

IsFloat

IsSlice

IsMap

IsStruct

ListItemValues

ListItemValuesUnique

Struct

Structs

Ints

Int64s

Uints

Uint64s

Floats

Float64s

Float32s

Strings

Interfaces

Slice

Array

Vars

Map

MapStrAny

MapStrStr

MapStrVar

MapDeep

MapStrStrDeep

MapStrVarDeep

Maps

MapsDeep

MapToMap

MapToMaps

MapToMapsDeep

Scan