golang进阶:错误处理(二)

 func Listen(net, laddr string) (Listener, error) {
     la, err := resolveAddr("listen", net, laddr, noDeadline)
     if err != nil {
         return nil,  OpError{Op: "listen", Net: net, Addr: nil, Err: err}
     }
     var l Listener
     switch la := la.toAddr().(type) {
     case *TCPAddr:
         l, err = ListenTCP(net, la)
     case *UnixAddr:
         l, err = ListenUnix(net, la)
     default:
         return nil,  OpError{Op: "listen", Net: net, Addr: la, Err:  AddrError{Err: "unexpected address type", Addr: laddr}}
     }
     if err != nil {
         return nil, err // l is non-nil interface containing nil pointer
     }
     return l, nil
 }

 // OpError is the error type usually returned by functions in the net
 // package. It describes the operation, network type, and address of
 // an error.
 type OpError struct {
     // Op is the operation which caused the error, such as
     // "read" or "write".
     Op string

     // Net is the network type on which this error occurred,
     // such as "tcp" or "udp6".
     Net string

     // Addr is the network address on which this error occurred.
     Addr Addr

     // Err is the error that occurred during the operation.
     Err error
 }

 func (e *OpError) Error() string {
     if e == nil {
         return "<nil>"
     }
     s := e.Op
     if e.Net != "" {
         s += " " + e.Net
     }
     if e.Addr != nil {
         s += " " + e.Addr.String()
     }
     s += ": " + e.Err.Error()
     return s
 }

 // An UnmarshalTypeError describes a JSON value that was
 // not appropriate for a value of a specific Go type.
 type UnmarshalTypeError struct {
     Value string // description of JSON value
     Type reflect.Type // type of Go value it could not be assigned to
 }

 func (e *UnmarshalTypeError) Error() string {
     return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String()
 }

 // An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
 // (The argument to Unmarshal must be a non-nil pointer.)
 type InvalidUnmarshalError struct {
     Type reflect.Type
 }

 func (e *InvalidUnmarshalError) Error() string {
     if e.Type == nil {
         return "json: Unmarshal(nil)"
     }

     if e.Type.Kind() != reflect.Ptr {
         return "json: Unmarshal(non-pointer " + e.Type.String() + ")"
     }
     return "json: Unmarshal(nil " + e.Type.String() + ")"
 }

 func Unmarshal(data []byte, v interface{}) error {
     // Check for well-formedness.
     // Avoids filling out half a data structure
     // before discovering a JSON syntax error.
     var d decodeState
     err := checkValid(data,  d.scan)
     if err != nil {
         return err
     }

     d.init(data)
     return d.unmarshal(v)
 }

 func (d *decodeState) unmarshal(v interface{}) (err error) {
     defer func() {
         if r := recover(); r != nil {
             if _, ok := r.(runtime.Error); ok {
                 panic
             }
             err = r.(error)
         }
     }()

     rv := reflect.ValueOf(v)
     if rv.Kind() != reflect.Ptr || rv.IsNil() {
         return  InvalidUnmarshalError{reflect.TypeOf(v)}
     }

     d.scan.reset()
     // We decode rv not rv.Elem because the Unmarshaler interface
     // test must be applied at the top level of the value.
     d.value(rv)
     return d.savedError
 }

 package main

 import (
     "encoding/json"
     "fmt"
     "log"
 )

 type user struct {
     Name int
 }

 func main() {
     var u user
     err := JSON.Unmarshal([]byte(`{"name":"bill"}`), &u)
     if err != nil {
         log.Println(err)
         return
     }

     fmt.Println("Name:", u.Name)
 }

Output:
09/11/10 23:00:00 JSON: cannot unmarshal string into Go value of type int

 package main

 import (
     "encoding/json"
     "fmt"
     "log"
 )

 type user struct {
     Name int
 }

 func main() {
     var u user
     err := JSON.Unmarshal([]byte(`{"name":"bill"}`), u)
     if err != nil {
         switch e := err.(type) {
         case *json.UnmarshalTypeError:
             log.Printf("UnmarshalTypeError: Value[%s] Type[%v]\n", e.Value, e.Type)
         case *json.InvalidUnmarshalError:
             log.Printf("InvalidUnmarshalError: Type[%v]\n", e.Type)
         default:
             log.Println(err)
         }
         return
     }

     fmt.Println("Name:", u.Name)
 }

Output:
09/11/10 23:00:00 JSON: Unmarshal(non-pointer main.user)
09/11/10 23:00:00 InvalidUnmarshalError: Type[main.user]

         switch e := err.(type) {
         case *json.UnmarshalTypeError:
             log.Printf("UnmarshalTypeError: Value[%s] Type[%v]\n", e.Value, e.Type)
         case *json.InvalidUnmarshalError:
             log.Printf("InvalidUnmarshalError: Type[%v]\n", e.Type)
         default:
             log.Println(err)
         }