When should I use this skill?

Use this skill only when your Go project uses GoFrame v2, indicated by github.com/gogf/gf/v2 in go.mod or imports. Do not use for generic Go projects, frontend work, or infrastructure tasks unrelated to GoFrame.

Should I manually set created_at and updated_at fields?

No. GoFrame automatically writes created_at on insert and updated_at on insert/update/save. Manually setting these fields is redundant and violates project conventions.

What should I use for database operations instead of g.Map?

Always use DO objects from internal/model/do/. DO struct fields are interface{}, unset fields remain nil and are automatically ignored by the ORM.

How does soft delete work in GoFrame?

Call Delete() on the DAO; GoFrame automatically converts it to UPDATE SET deleted_at = NOW(). Queries automatically filter out soft-deleted rows without requiring manual WhereNull conditions.

Where should I implement business logic?

Implement business logic directly in the service/ directory. Do not use the logic/ directory unless explicitly requested.

goframe-v2 by gogf

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

/goframe-v2

goframe-v2references组件列表数据结构泛型类型-gvar泛型类型-方法介绍.md

New

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

Third-party checks

Provenance

Topics

README badge

What it does

Frequently asked

Related skills

references组件列表数据结构泛型类型-gvar泛型类型-方法介绍.md