泛型类型-方法介绍

以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档：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"
}

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]",
    // }
}