Categories: GoFrame 教程

GoFrame gvar-方法介绍

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

  • 说明：​GTime​将​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​转换为​[]strin​g。
  • 格式：
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]",
 // }
}

admin

这个人很懒，什么都没有留下～

Leave a Comment
Share
Published by
admin
1 年 ago

Recent Posts

聊聊vue3中的defineProps

在Vue 3中，defineP…

1 周 ago

在 Chrome 中删除、允许和管理 Cookie

您可以选择删除现有 Cooki…

2 周 ago

自定义指令：聊聊vue中的自定义指令应用法则

今天我们来聊聊vue中的自定义…

3 周 ago

聊聊Vue中@click.stop和@click.prevent

一起来学下聊聊Vue中@cli…

4 周 ago

Nginx 基本操作：启动、停止、重启命令。

我们来学习Nginx基础操作：…

1 月 ago

Vue3：手动清理keep-alive组件缓存的方法

Vue3中手动清理keep-a…

1 月 ago