golang中的错误处理模式

发表于2015-04-14由daniel

年前拜读了Rob Pike的Errors are values，不禁感叹——原来错误可以这样处理。这里简单做一个笔记。

模式1：闭包记录异常

var err error
write := func(buf []byte) {
    if err != nil {
        return
    }
    _, err = w.Write(buf)
}
write(p0[a:b])
write(p1[c:d])
write(p2[e:f])
// and so on
if err != nil {
    return err
}

var err error

write := func(buf []byte) {

if err != nil {

return

}

_, err = w.Write(buf)

}

write(p0[a:b])

write(p1[c:d])

write(p2[e:f])

// and so on

if err != nil {

return err

}

这种方式适用于多次相同类型调用的错误处理。缺点就是，每个类似的地方都需要引入一个闭包函数，显得冗余重复。

模式2：组合error struct

type errWriter struct {
    w   io.Writer
    err error
}

func (ew *errWriter) write(buf []byte) {
    if ew.err != nil {
        return
    }
    _, ew.err = ew.w.Write(buf)
}

...

ew := &errWriter{w: fd}
ew.write(p0[a:b])
ew.write(p1[c:d])
ew.write(p2[e:f])
// and so on
if ew.err != nil {
    return ew.err
}

type errWriter struct {

w io.Writer

err error

}

func (ew *errWriter) write(buf []byte) {

if ew.err != nil {

return

}

_, ew.err = ew.w.Write(buf)

}

...

ew := &errWriter{w: fd}

ew.write(p0[a:b])

ew.write(p1[c:d])

ew.write(p2[e:f])

// and so on

if ew.err != nil {

return ew.err

}

代码比第一种方式更加干净。但是与第一种方式有一样的问题，就是无法具体的知道是在哪个位置发生的错误以及错误的具体信息。

模式3：error转化为panic

来自知乎唐生的回答：

func ce(msg string, err error) {                                                                                                                                           
 if err != nil {                                                                                                                                                           
  panic(fmt.Errorf("%s error: %v", msg, err))                                                                                                                              
 }                                                                                                                                                                         
}                                                                                                                                                                          
                                                                                                                                                                           
func catch(err *error) {                                                                                                                                                   
 if p := recover(); p != nil {                                                                                                                                             
  *err = p.(error)                                                                                                                                                         
 }                                                                                                                                                                         
}                                                                                                                                                                          
                                                                                                                                                                           
func foo() (err error) {                                                                                                                                                   
 defer catch(&err)                                                                                                                                                         
                                                                                                                                                                           
 // ...                                                                                                                                                                    
 ce("duang", err)                                                                                                                                                          
 // ...                                                                                                                                                                    
 ce("duang", err)                                                                                                                                                          
 // ...                                                                                                                                                                    
 ce("duang", err)                                                                                                                                                          
                                                                                                                                                                           
 return                                                                                                                                                                    
}

func ce(msg string, err error) {

if err != nil {

panic(fmt.Errorf("%s error: %v", msg, err))

}

func catch(err *error) {

if p := recover(); p != nil {

*err = p.(error)

}

func foo() (err error) {

defer catch(&err)

// ...

ce("duang", err)

// ...

ce("duang", err)

// ...

ce("duang", err)

return

}

这种方式的通用性较好。但是把error主动转化为panic会导致goroutine的stack unwind。这会带来一定的系统开销，甚至是系统性能抖动。

参考：

你应该记住的一个UTF-8字符「EF BF BD」

发表于2015-03-28由daniel

utf-8是一种变长（1 byte ~ 6 bytes）的unicode字符集编码方案。所谓编码方案即讲字符集到码点（code point）的映射方式。

在众多的utf-8码点值中，除了ascii，你还应该记住「EF BF BD」，因为它是很多编程语言以及库中的备胎，即无效的码点值在编码的时候会默认用这个码点值进行替换，即utf-8中的超级「备胎」(REPLACEMENT CHARACTER)。

为什么会有无效的码点值？

UTF-8 Code Point

从上图可以知道，utf-8编码 并非连续的 。很多人会忽略这个细节。

什么时候会遇到无效的utf-8码点？

当你试图把一个无效的码点值作为utf-8码点处理时，就会产生无效的码点。此时，无效的码点会被替换为「EF BF BD」，然后进行后续处理，以避免无效码点可能引起的异常。很多语言对这种处理是 自动进行 的，比如golang:

now := time.Now().Unix() // 一个无效的码点值
str := string(now) // golang是utf-8编码，会对无效码点进行替换
fmt.Printf("%X", []byte(str)) // EFBFBD，即字符「�」

now := time.Now().Unix() // 一个无效的码点值

str := string(now) // golang是utf-8编码，会对无效码点进行替换

fmt.Printf("%X", []byte(str)) // EFBFBD，即字符「�」

为什么要记住这个码点

在「字符集敏感」的环境中，如果你的数据中出现了「EF BF BD」就应该警惕了，因为你传输的数据中途很可能经过了自动替换，收到的数据未必是原始的数据。这对于你排查一些奇怪的数据交换不一致问题是很有用的，很多时候，可能是你的最后一颗救命稻草。

例如，使用utf-8编码的xml文档进行数据交换，如果看见了「�」，毫无疑问数据源有非法码点值。网页中出现了「�」，那么肯定是html文档的编码不是合规的utf-8编码文档。文本编辑器中出现了「�」，那一定是你打开这个文档的姿势不对——又选错编码了。总之，当你看见超级备胎「�」的时候，不要觉得大事不妙，不要像遇到一般乱码那样惊慌失措，你应该轻轻弹一下鼠标上的灰尘，将之打回原形。

因为aws的账单，才意识到自己的vps已经很久没有折腾了，博客也已经长草，应该说已经长成灌木丛了。

这才意识到自己已经回成都快9个月了。

有人说，时间是把杀猪刀。这很公平。但是，即使哪天挨上了这杀猪刀，也希望自己是头优雅的猪。

而此时，2015已经过去1/4.

golang中接收者初探

发表于2014-06-17由daniel

今天使用net/http库做了一个简单的server. 遇到一个之前自己忽略的问题，觉得挺有意思，简单做一个笔记。

server通过调用

func ListenAndServe(addr string, handler Handler) error

1	func ListenAndServe(addr string, handler Handler) error

实现。需要传递一个Handler类型的接口进行request/response的处理。Handler接口定义如下：

type Handler interface {
        ServeHTTP(ResponseWriter, *Request)
}

type Handler interface {

ServeHTTP(ResponseWriter, *Request)

}

一切都非常简单，于是花了一分钟，写了一个server：

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
)

type MyServer struct {
    i int
}

func (myServer *MyServer) ServeHTTP(w http.ResponseWriter, request *http.Request) {
    io.WriteString(w, "Hello")
    fmt.Println(request.UserAgent())
}

func main() {
    myServer := MyServer{1}
    err := http.ListenAndServe(":8080", myServer)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

package main

import (

"fmt"

"io"

"log"

"net/http"

)

type MyServer struct {

i int

}

func (myServer *MyServer) ServeHTTP(w http.ResponseWriter, request *http.Request) {

io.WriteString(w, "Hello")

fmt.Println(request.UserAgent())

}

func main() {

myServer := MyServer{1}

err := http.ListenAndServe(":8080", myServer)

if err != nil {

log.Fatal("ListenAndServe: ", err)

}

看似一切都没有问题的样子……但是却编译错误：

cannot use myServer (type MyServer) as type http.Handler in function argument:
    MyServer does not implement http.Handler (ServeHTTP method has pointer receiver)

1 2	cannot use myServer (type MyServer) as type http.Handler in function argument: MyServer does not implement http.Handler (ServeHTTP method has pointer receiver)

原来是类型不匹配的问题。具体来说，接收者的类型才是真正实现接口的类型。在本例中，接收者类型是*Myserver，myServer也必须是一个指针。fix后的代码如下：

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
)

type MyServer struct {
    i int
}

func (myServer *MyServer) ServeHTTP(w http.ResponseWriter, request *http.Request) {
    io.WriteString(w, "Hello")
    fmt.Println(request.UserAgent())
}

func main() {
    myServer := &MyServer{1}
    err := http.ListenAndServe(":8080", myServer)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

package main

import (

"fmt"

"io"

"log"

"net/http"

)

type MyServer struct {

i int

}

func (myServer *MyServer) ServeHTTP(w http.ResponseWriter, request *http.Request) {

io.WriteString(w, "Hello")

fmt.Println(request.UserAgent())

}

func main() {

myServer := &MyServer{1}

err := http.ListenAndServe(":8080", myServer)

if err != nil {

log.Fatal("ListenAndServe: ", err)

}

行思錄 | Travel Coder

Arch, Coding, Life

分类目录归档：Golang

golang中的错误处理模式

模式1：闭包记录异常

模式2：组合error struct

模式3：error转化为panic

你应该记住的一个UTF-8字符「EF BF BD」

为什么会有无效的码点值？

什么时候会遇到无效的utf-8码点？

为什么要记住这个码点

golang中接收者初探