error数据类型
在前面的例子中，已经大量地用到了error这个数据类型。而且虽然未加说明，已经能够蒙着用这个数据类型。——编程经常就是凭着感觉蒙着干活，而且这代码还能够很好地工作。最后再查阅资料，找到佐证，心理上再得到一番安慰/踏实。
严格来讲，与其说error类型，不如说error接口。其定义如下：
type error interface {
Error() string
}
既然是接口，那么在使用的时候，遇到的都是error的实现。接下来，以打开文件为例，对error展开说明。
os.Open()
godoc
D:\examples>godoc cmd/os Open
type File struct {
// contains filtered or unexported fields
}
File represents an open file descriptor.
func Open(name string) (*File, error)
Open opens the named file for reading. If successful, methods on the
returned file can be used for reading; the associated file descriptor
has mode O_RDONLY. If there is an error, it will be of type *PathError.
PathError
如同godoc所述，当Open出错的时候，对应的是PathError类型，其为error接口的一个实现。代码如下(src\os\error.go):
// PathError records an error and the operation and file path that caused it.
type PathError struct {
Op string
Path string
Err error
}
func (e *PathError) Error() string { return e.Op + " " + e.Path + ": " + e.Err.Error() }
这里PathError struct实现了error接口的func Error() string方法，所以说PathError是error的一个实现。PathError中，有一个Err error成员，自然地，这又是某个error实现。
Open()实现代码
Open() - src/os/file.go
// Open opens the named file for reading. If successful, methods on
// the returned file can be used for reading; the associated file
// descriptor has mode O_RDONLY.
// If there is an error, it will be of type *PathError.
func Open(name string) (*File, error) {
return OpenFile(name, O_RDONLY, 0)
}
OpenFile() - src/os/file_windows.go
// OpenFile is the generalized open call; most users will use Open
// or Create instead. It opens the named file with specified flag
// (O_RDONLY etc.) and perm, (0666 etc.) if applicable. If successful,
// methods on the returned File can be used for I/O.
// If there is an error, it will be of type *PathError.
func OpenFile(name string, flag int, perm FileMode) (*File, error) {
if name == "" {
return nil, &PathError{"open", name, syscall.ENOENT}
}
r, errf := openFile(name, flag, perm)
if errf == nil {
return r, nil
}
r, errd := openDir(name)
if errd == nil {
if flag&O_WRONLY != 0 || flag&O_RDWR != 0 {
r.Close()
return nil, &PathError{"open", name, syscall.EISDIR}
}
return r, nil
}
return nil, &PathError{"open", name, errf}
}
可以看到OpenFile()返回的的确是PathError类型。注意到return语句中的&。这在Go-interface中有说明。
syscall.EXXXXX - src/syscall/errors_plan9.go
// Errors
var (
EINVAL = NewError("bad arg in system call")
ENOTDIR = NewError("not a directory")
EISDIR = NewError("file is a directory")
ENOENT = NewError("file does not exist")
EEXIST = NewError("file already exists")
EMFILE = NewError("no free file descriptors")
EIO = NewError("i/o error")
ENAMETOOLONG = NewError("file name too long")
EINTR = NewError("interrupted")
EPERM = NewError("permission denied")
EBUSY = NewError("no free devices")
ETIMEDOUT = NewError("connection timed out")
EPLAN9 = NewError("not supported by plan 9")
// The following errors do not correspond to any
// Plan 9 system messages. Invented to support
// what package os and others expect.
EACCES = NewError("access permission denied")
EAFNOSUPPORT = NewError("address family not supported by protocol")
)
这里给出的是PathError的err Error成员，的确也是一个error实现。——当然，需要进一步确定NewError()。这又是什么鬼？
NewError() - src/syscall/syscall_plan9.go
NewError()是一个函数，把一个字符串转换成为一个ErrorString对象。
// NewError converts s to an ErrorString, which satisfies the Error interface.
func NewError(s string) error { return ErrorString(s) }
ErrorString() - src/syscall/syscall_plan9.go
ErrorString既是string，又是error对象。——这里的type类似于C/C++的typedef。
// ErrorString implements Error's String method by returning itself.
type ErrorString string
func (e ErrorString) Error() string { return string(e) }
小结
现在转了一大圈，就是把PathError以及PathError中的err对象全部过了一遍。结论就是PathError是error实现，ErrorString是error实现。——其实整个Go中，有大量的error实现。但只限于注意其只有一个func Error() string方法即可，其返还error的详细信息。
fmt.Println(err)
示例代码
package main
import (
"fmt"
"os"
)
func main() {
file, err := os.Open("abcdefg.xyz")
if err != nil {
fmt.Println("err: ", err)
fmt.Println("Error():", err.Error())
} else {
fmt.Println("Open OK.")
file.Close()
}
}
输出结果
D:\examples>go run helloworld.go
err: open abcdefg.xyz: The system cannot find the file specified.
Error(): open abcdefg.xyz: The system cannot find the file specified.
D:\examples>
Println()的入参
注意到Println()的两种入参：
fmt.Println("err: ", err)
fmt.Println("Error():", err.Error())
打印结果是一样的。
难不成Go也有Java一样的toString()方法？事实上，Go比Java更加智能，关于这一块，不再展开(目前还没有分析透彻)，只给出src/fmt/print.go的如下代码。简单说，就是会利用反射机制，自动调用error接口的Error()方法，打印这个方法的返回值。所以，以上两种入参的效果是一样的。当然，后者的性能更优。
func (p *pp) printArg(arg interface{}, verb rune) {
//...
// Some types can be done without reflection.
switch f := arg.(type) {
case bool:
p.fmtBool(f, verb)
//...
case string:
p.fmtString(f, verb)
case []byte:
p.fmtBytes(f, verb, "[]byte")
case reflect.Value:
p.printValue(f, verb, 0)
default:
// If the type is not simple, it might have methods.
if !p.handleMethods(verb) {
// Need to use reflection, since the type had no
// interface methods that could be used for formatting.
p.printValue(reflect.ValueOf(f), verb, 0)
}
}
}
实用函数
上面描述的内容似乎和日常编码没有多大关系，接下来聊聊一些实用方面。
package errors
源代码
这个包的内容很少，直接拷贝过来（省略掉版权信息）：
// Package errors implements functions to manipulate errors.
package errors
// New returns an error that formats as the given text.
func New(text string) error {
return &errorString{text}
}
// errorString is a trivial implementation of error.
type errorString struct {
s string
}
func (e *errorString) Error() string {
return e.s
}
也就是说，errors这个包只有一个对外可见的函数，即New()，其返还一个实现了error接口的对象（即errorString实现)。
示例代码
package main
import (
"fmt"
"errors"
)
func myadd(x, y int) (ret int, err error) {
if x <= 0 || y <= 0 {
err = errors.New("x or y less or equal 0!")
return
} else {
ret = x + y
err = nil
return
}
}
func test(x, y int) {
ret, err := myadd(x, y)
if err != nil {
fmt.Println(err.Error())
} else {
fmt.Println(ret)
}
}
func main() {
test(0, 1)
test(1, 0)
test(-1, 1)
test(1, -1)
test(1, 1)
}
运行结果：
D:\examples>go run helloworld.go
x or y less or equal 0!
x or y less or equal 0!
x or y less or equal 0!
x or y less or equal 0!
2
D:\examples>
fmt.Errorf()
这是更加实用的一个函数。
源代码 - src/fmt/print.go
// Sprintf formats according to a format specifier and returns the resulting string.
func Sprintf(format string, a ...interface{}) string {
p := newPrinter()
p.doPrintf(format, a)
s := string(p.buf)
p.free()
return s
}
// Errorf formats according to a format specifier and returns the string
// as a value that satisfies error.
func Errorf(format string, a ...interface{}) error {
return errors.New(Sprintf(format, a...))
}
示例
只需要把上例myadd中的一句话替换为：//哦，还要注释掉errors的import。
err = fmt.Errorf("x(%d) or y(%d) less or equal 0!", x, y)
运行结果：
D:\examples>go run helloworld.go
x(0) or y(1) less or equal 0!
x(1) or y(0) less or equal 0!
x(-1) or y(1) less or equal 0!
x(1) or y(-1) less or equal 0!
2
D:\examples>
![Linux之父警告全球程序员：我刚发布的5.12内核有bug，你们千万别用[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)