Golang开发过程中常遇到得一些小错误

JSON反序列化Int64类型

JSON在序列化结构体的时候，如果结构体中包含Int64类型的数值类型，序列号之后会导致int64类型变成float64类型，因为JSON里面没有int64。因此导致序列号之后的数值不正确。如果反序列化用map[string]interface{}接，会得到浮点型数据。

type number struct {
    N int64
}

func main() {
    s := number{29882837987845}
    marshal, _ := json.Marshal(s)
    var r map[string]interface{}
    json.Unmarshal(marshal, &r)
    fmt.Println(r)   //map[N:2.9882837987845e+13]
}

正确处理方式：

func main() {
    s := number{29882837987845}
    marshal, _ := json.Marshal(s)
    decoder := json.NewDecoder(bytes.NewReader(marshal))
    decoder.UseNumber()
    var r map[string]interface{}
    decoder.Decode(&r)
    fmt.Println(r)     //map[N:29882837987845]
}

匿名函数共用参数，结果不正确

func main() {
    var wg sync.WaitGroup
    for i := 0; i< 10; i++ {
        go func() {
            wg.Add(1)
            defer wg.Done()
            fmt.Println(i)
        }()
    }
    wg.Wait()
}

以上打印结果会随机：

7
10
10
10
10
10

这里写错的原因是所有的go协程都共用了i变量导致，协程被调度切换导致结果不确定。

正确写法：

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        go func(i int) {
            wg.Add(1)
            defer wg.Done()
            fmt.Println(i)
        }(i)
    }
    wg.Wait()
}

map未初始化，导致panic:

func main() {
    var m map[string]int
    m["s"] = 1
    fmt.Println(m["s"])
}

正确写法：

func main() {
    var m = make(map[string]int)
    m["s"] = 1
    fmt.Println(m["s"])
}

注意：可以使用len函数获取map的长度，但是不能用cap获取map的容量。

grpc服务端实现接口函数时，返回类型为*emptypb.Empty指针类型，不能返回nil。

func (ds *Server) Update(ctx context.Context, req *devRPC.Update) (*emptypb.Empty, error) {
    for _, dev := range req.UpdateDes {
        devDTO := dtos.FromRpcToUpdateDev(dev)
        err := application.PatchDev(ctx, devDTO, ds.dic)
        if err != nil {
            return nil, errors.ConvertEdgeXErrToRpc(err)
        }
    }

    return nil, nil
}

备注：使用nil，在序列号和反序列化中，会错误结果。

正确写法：

func (ds *Server) Update(ctx context.Context, req *devRPC.Update) (*emptypb.Empty, error) {
    for _, dev := range req.UpdateDevs {
        devDTO := dtos.FromRpcToUpdateDev(dev)
        err := application.PatchDev(ctx, devDTO, ds.dic)
        if err != nil {
            return &emptypb.Empty{}, errors.ConvertEdgeXErrToRpc(err)
        }
    }

    return &emptypb.Empty{}, nil
}

HTTP响应未正确关闭

func main() {
    resp, err := http.Get("https://api.ipify.org?format=json")
    defer resp.Body.Close()//可能发生panic
    if err != nil {
        fmt.Println(err)
        return
    }
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(body))
}

如果resp的值nil的话，resp.Body.Close()会导致panic。

正确的写法：

func main() {
    resp, err := http.Get("https://api1.ipify.org?format=json")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(body))
}

在http.Get返回错误检查过后，再调用defer就不会panic。

HTTP响应关闭正确做法

前面的做法还不是很周全，如果http.Get获取的是一个重定向过的结果，err和resp都不是nil，也会导致resp未关闭。最好还是对resp做判断：

    resp, err := http.Get("https://api1.ipify.org?format=json")
    if resp != nil {
        defer resp.Body.Close()
    }
    if err != nil {
        fmt.Println(err)
        return
    }
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(body))
}

关闭HTTP连接

默认情况下，标准http库只在目标HTTP服务器要求关闭时才会关闭网络连接。这意味着你的应用在某些条件下会消耗完sockets/file的文件描述符。

你可以通过设置请求变量中的Close域的值为true，来让http库在请求完成时关闭连接。

另一个选项是添加一个Connection的请求头，并设置为close。目标HTTP服务器应该也会响应一个Connection: close的头。当http库看到这个响应头时，它也将会关闭连接。

func main() {
    req, err := http.NewRequest("GET","http://golang.org",nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    req.Close = true
    //也可以使用下面方式
    //req.Header.Add("Connection", "close")

    resp, err := http.DefaultClient.Do(req)
    if resp != nil {
        defer resp.Body.Close()
    }
    if err != nil {
        fmt.Println(err)
        return
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(len(string(body)))
}

备注：如果你向同一个HTTP服务器发送大量的请求，那么把保持网络连接的打开是没问题的。然而，如果你的应用在短时间内向大量不同的HTTP服务器发送一两个请求，那么在引用收到响应后立刻关闭网络连接是一个好主意。增加打开文件的限制数可能也是个好主意。当然，正确的选择源自于应用。

recover只能直接在defer函数内有效

func doRecover() {  
    fmt.Println("recovered =>",recover()) //prints: recovered => <nil>
}

func main() {  
    defer func() {
        doRecover() //panic is not recovered
    }()

    panic("not good")
}

上面的panic不能被捕获。

func main() {  
    defer func() {
        fmt.Println("recovered:",recover())
    }()

    panic("not good")
}