04-结构体

排序

    var cols []string
    var cds []mo.ColumnDefinition
    // 使用sort包进行排序
    for _, v := range obj.Cols {
        cds = append(cds, v)
    }
    sort.Slice(cds, func(i, j int) bool {
        return   cds[i].Sort < cds[j].Sort
    })
    for _, v := range cds {
        cols = append(cols, formatCol(v))
    }

嵌套 JSON 数据

type Btn struct{
  Name string  `json:"name"`
  Type string  `json:"type"`
  Url string   `json:"url"`
  Sub_button  []Btn  `json:"sub_button,omitempty"` //值为空时 直接忽略
  UnShow string `json"-"`  //忽略字段
}

type menu struct{
  Button []Btn   `json:"button"`
}

JSON

package main

import(
    "encoding/json"
    "fmt"
)


type Order struct{
    OrderId string `json:"order_id"`
    OrderPrice float64 `json:"order_price"`
    Goods []Good `json:"good"`
}

type Good struct{

    GoodsName string `json:"goods_name"`
    GoodsPrice float64 `json:"goods_price"`
    GoodsColor []Color `json:"Goods_color"`
}

type Color struct{

    GoodColor string `json:"good_color"`
}

func main(){
    var OrderInfo Order
    OrderInfo.OrderId = "20190707212318"
    OrderInfo.OrderPrice = 26.87

    var csli []Color
    csli=append(csli,Color{GoodColor:"红色"})
    csli=append(csli,Color{GoodColor:"蓝色"})

    OrderInfo.Goods =append(OrderInfo.Goods,Good{GoodsName:"手机",GoodsPrice:23.9,GoodsColor:csli})

    OrderInfo.Goods =append(OrderInfo.Goods,Good{GoodsName:"电脑",GoodsPrice:123.9,GoodsColor:csli})

 // 结构体 转 JSON
    data ,_ := json.Marshal(OrderInfo)
    fmt.Println(string(data))

    /*
{
    "order_id": "20190707212318",
    "order_price": 26.87,
    "good": [{
        "goods_name": "手机",
        "goods_price": 23.9,
        "Goods_color": [{
            "good_color": "红色"
        }, {
            "good_color": "蓝色"
        }]
    }, {
        "goods_name": "电脑",
        "goods_price": 123.9,
        "Goods_color": [{
            "good_color": "红色"
        }, {
            "good_color": "蓝色"
        }]
    }]
}
    */


 // JSON 转 结构体
    var temp Order
    err := json.Unmarshal(data,&temp)

    if err !=nil{
        fmt.Println(err)
    }

    fmt.Println(temp)

    //{20190707212318 26.87 [{手机 23.9 [{红色} {蓝色}]} {电脑 123.9 [{红色} {蓝色}]}]}


}

继承

type Animal struct {
    name string
}

func (a *Animal) move() {
    fmt.Printf("%s在吃饭！\n", a.name)
}

type Dog struct {
    Feet    int
    *Animal //通过嵌套匿名结构体实现继承
}

func (d *Dog) wang() {
    fmt.Printf("%s不会吃饭！\n", d.name)
}

func main() {
    d := &Dog{
        Feet: 4,
        Animal: &Animal{ 
            name: "狗蛋",
        },
    }
    d.wang() //狗蛋会汪汪汪~
    d.move() //狗蛋会动！
}

修改

去除结构体空格

//@function: TrimSpace
//@description: 去除结构体空格
//@param: target interface (target: 目标结构体,传入必须是指针类型)
//@return: null
func TrimSpace(target interface{}) {
    t := reflect.TypeOf(target)
    if t.Kind() != reflect.Ptr {
        return
    }
    t = t.Elem()
    v := reflect.ValueOf(target).Elem()
    for i := 0; i < t.NumField(); i++ {
        switch v.Field(i).Kind() {
        case reflect.String:
            v.Field(i).SetString(strings.TrimSpace(v.Field(i).String()))
        }
    }
}

查询