What's the canonical way to differentiate errors?

For example, you open a file and get back a PathError.

How would you differentiate between (say) a file not found and a permission error.

---

评论：

natefinch:

This is the best guide I've seen:
https://dave.cheney.net/2016/04/27/dont-just-check-errors-handle-them-gracefully

JackOhBlades:

That post really helped me with Go's error handling. 

TLDR; check for the behaviour of the error, not the concrete type. 

type Temporary interface {
    IsTemporary() bool
}
_, err := canFail(..)
if temp, ok := err.(Temporary); ok {
    // handle the temporary error
    If temp.IsTemporary() {
        //...
    }
}

Hope this helps!

ragefacesmirk:

The grpc library offers a good working example.

jerf:

Cast the error back into its underlying type (generally the two-argument form to avoid crashing if you are wrong), and then use whatever that type offers to determine the more-specific problem.
If the type doesn't offer any useful methods or public fields, you are out of luck. That's why it's important to be careful with what errors you return; any data discarded by what you return stays discarded.

riking27:

The two-argument form looking like this:
if err, ok := err.(*os.PathError); ok {
    // ... check code ...
} else if err != nil {
    // ... other errors ...
}

tgaz:

Type assertion as /u/jerf suggests.
The other common way is to have a boolean function to identify classes of errors, like os.IsPermission. Internally that could do whatever. In os, they look at errno values.

natefinch:

note there's an os.IsNotExist as well.  These two functions are what you need for your specific case.  In the general case, use Dave Cheney's handling errors by behavior.