lyloou

type Na struct {
    name string
}

type Ia interface {
}

func main() {
    var e error
    var na Na
    var ia Ia
    fmt.Println(na, e, ia)

    n := new(Na)
    i := new(Ia)
    fmt.Println(n, i)

    c := make([]byte, 2, 5)
    fmt.Println(c)
}
/* output:
{} <nil> <nil>
&{} 0xc042008270
[0 0]
*/

var v = make([]byte, 10, 20)
v[0] = 0
v[1] = 1
v[2] = 2
v[9] = 32
v = v[:cap(v)]  // We can grow s to its capacity by slicing it again  https://blog.golang.org/go-slices-usage-and-internals
v[10] = 33
fmt.Println(v)

var n = new([]byte)
n = &v
fmt.Println(*n)
/* output:
[0 1 2 0 0 0 0 0 0 32 33 0 0 0 0]
[0 1 2 0 0 0 0 0 0 32 33 0 0 0 0]
*/

if val, ok := dict["foo"]; ok {
    //do something here
}

package main

import "fmt"

func main() {
    arr := []int64{1, 2, 3, 4, 6, 8, 9, 10, 11, 23}
    for i := len(arr) - 1; i >= 0; i-- {
     if arr[i]%2 == 0 {
      arr = append(arr[:i], arr[i+1:]...)
     }
    }
    fmt.Println(arr)
}

// 方案1 
specProps := product.SpecProps
spec := models.Spec{}
err := json.Unmarshal([]byte(specProps), &spec)
if err == nil {
    sItem := make([]models.SpecChildren, 0)
    for _, v := range spec.Spec {
        scItem := make([]models.SpecChildrenItem, 0)
        for _, vv := range v.Children {
            if vv.Selected {
                vv.Selected = false
                scItem = append(scItem, vv)
            }
        }
        v.Children = scItem
        sItem = append(sItem, v)
    }
    spec.Spec = sItem

    data, err := json.Marshal(spec)
    if err == nil {
        product.SpecProps = string(data)
    }
}

// 方案2
specProps := product.SpecProps
spec := models.Spec{}
err := json.Unmarshal([]byte(specProps), &spec)
if err == nil {
    for j := 0; j < len(spec.Spec); j++ {
        v := &spec.Spec[j] // Note: need pointer
        for i := len(v.Children) - 1; i >= 0; i-- {
            if !v.Children[i].Selected {
                // https://vbauerster.github.io/2017/04/removing-items-from-a-slice-while-iterating-in-go/
                v.Children = append(v.Children[:i], v.Children[i+1:]...)
            }
        }
    }

    specData, err := json.Marshal(spec)
    if err == nil {
        product.SpecProps = string(specData)
    }
}

package main

import (
    "fmt"
    "encoding/json"
)

type User struct {
    name string
}

func main() {
    user := &User{name:"Frank"}
    b, err := json.Marshal(user)
    if err != nil {
        fmt.Printf("Error: %s", err)
        return;
    }
    fmt.Println(string(b))
}

var cfg = beego.AppConfig

type AddressController struct {
        baseController
}

func (ac AddressController) Address() {
    userId := ac.GetString("user_id")
    var url = cfg.String("third::user_url") + "/user/address?user_id=" + userId
    body, err := get(url)
    if err != nil {
        logs.Error("get Address error:", err)
        return
    }
    ac.Data["json"] = string(body)
    ac.ServeJSON()
}

func (ac AddressController) AddAddress() {
    userId := ac.GetString("user_id")
    var url = cfg.String("third::user_url") + "/user/add_address?user_id=" + userId

    body, err := post(url, ac.Ctx.Input.RequestBody)
    if err != nil {
        logs.Error("post AddAddress error:", err)
        return
    }
    ac.Data["json"] = string(body)
    ac.ServeJSON()
}

func get(url string) ([]byte, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return ioutil.ReadAll(resp.Body)
}

func post(url string, data []byte) ([]byte, error) {
    body := bytes.NewBuffer(data)
    resp, err := http.Post(url, "application/json;charset=utf-8", body)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return ioutil.ReadAll(resp.Body)
}

o := orm.NewOrm()
qs = o.QueryTable("user");
var pageSize = 50 // 一页50条
var pageNo = 3 // 准备取第三页
// qs.Limit("[取多少个]","[偏移行数]");
qs = qs.Limit(pageSize, pageNo*pageSize) // 请注意和MySQL语法的区别：LIMIT 50*3, 50

func analyseParams(params *[]orm.Params) {
    keyImage := "image"
    keyStatus := "status"
    keyEndAt := "end_at"
    for _, param := range *params {
        // replace image
        if vv, ok := param[keyImage]; ok {
            r := reflect.ValueOf(vv)
            if r.Kind() == reflect.String {
                temp_arr := strings.Split(r.String(), ",")
                param[keyImage] = commons.ImagePath(temp_arr[0])
            }
        }

        // add status
        if vv, ok := param[keyEndAt]; ok {
            r := reflect.ValueOf(vv)
            if r.Kind() == reflect.String {
                now := time.Now().UnixNano()
                startTime, err := time.Parse("2006-01-02 15:04:05", r.String())
                if err != nil {
                    logs.Error("转换时间错误：", err)
                    continue
                }
                if startTime.UnixNano() > now {
                    param[keyStatus] = "notbegin"
                }
            }
        }
        
        // delete marketable_at
        delete(params, "marketable_at")
    }
}

// 顺序
sort.Ints(a []int);
sort.Strings(a []string);
// 逆序 https://stackoverflow.com/questions/18343208/how-do-i-reverse-sort-a-slice-of-integer-go
sort.Sort(sort.Reverse(sort.IntSlice(keys)))
sort.Sort(sort.Reverse(sort.StringSlice(keys)))

timeStr := time.Now().Format("2006-01-02 15:04:05")
timeStr = time.Parse("2006-01-02 15:04:05", time.Now)

c := make([]int, 0)
fmt.Println(len(c), c == nil)
c = nil
fmt.Println(len(c), c == nil)
// Output:
// 0, false
// 0, true

type S struct {
	SS S // error: invalid recursive type S 
	II int
}

type S struct {
	SS *S // ok 
	II int
}

type Point struct {
但结构体字面值必须遵循形状类型声明时的结构
    X, Y int
}

type Circle struct {
    Center Point
    Radius int
}

type Wheel struct {
    Circle Circle
    Spokes int
}

var w Wheel
w.X = 8            // equivalent to w.Circle.Point.X = 8
w.Y = 8            // equivalent to w.Circle.Point.Y = 8
w.Radius = 5       // equivalent to w.Circle.Radius = 5
w.Spokes = 20

// 但结构体字面值必须遵循形状类型声明时的结构
w = Wheel{8, 8, 5, 20}                       // compile error: unknown fields
w = Wheel{X: 8, Y: 8, Radius: 5, Spokes: 20} // compile error: unknown fields

b := a[:0]

type Rectangle struct {
        width, height float64
}

type Circle struct {
    radius float64
}

func (r Rectangle) area() float64 {
    return r.width*r.height
}

func (c Circle) area() float64 {
    return c.radius * c.radius * math.Pi
}

type ages int
type money float32
type months map[string]int
m := months {
    "January":31,
    "February":28,
    ...
    "December":31,
}

type P *int
func (P) f() { /* ... */ } // compile error: invalid receiver type