Go：常见错误集合(1)

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()}

以上打印结果会随机：

71010101010

这里写错的原因是所有的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库只在目标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服务器发送一两个请求，那么在收到响应后立刻关闭网络连接是一个好主意。增加打开文件的限制数可能也是个好主意。当然，正确的选择源自于应用。

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))}

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")}

490100Go：常见错误集合(1)

Go：常见错误集合(1)

文章评论