Documentation
¶
Overview ¶
Package errors implements functions to manipulate errors.
This package implements the Go 2 draft designs for error inspection and printing:
https://go.googlesource.com/proposal/+/master/design/go2draft.md
This is an EXPERIMENTAL package, and may change in arbitrary ways without notice.
Example ¶
package main
import (
"fmt"
"time"
)
// MyError is an error implementation that includes a time and message.
type MyError struct {
When time.Time
What string
}
func (e MyError) Error() string {
return fmt.Sprintf("%v: %v", e.When, e.What)
}
func oops() error {
return MyError{
time.Date(1989, 3, 15, 22, 30, 0, 0, time.UTC),
"the file system has gone away",
}
}
func main() {
if err := oops(); err != nil {
fmt.Println(err)
}
}
Output: 1989-03-15 22:30:00 +0000 UTC: the file system has gone away
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func As ¶
As finds the first error in err's chain that matches a type to which target points, and if so, sets the target to its value and reports success. An error matches a type if it is of the same type, or if it has an As method such that As(target) returns true. As will panic if target is nil or not a pointer.
The As method should set the target to its value and report success if err matches the type to which target points and report success.
Example ¶
package main
import (
"fmt"
"os"
"golang.org/x/exp/errors"
)
func main() {
_, err := os.Open("non-existing")
if err != nil {
var pathError *os.PathError
if errors.As(err, &pathError) {
fmt.Println("Failed at path:", pathError.Path)
}
}
}
Output: Failed at path: non-existing
func Is ¶
Is returns true if any error in err's chain matches target.
An error is considered to match a target if it is equal to that target or if it implements an Is method such that Is(target) returns true.
func New ¶
New returns an error that formats as the given text.
The returned error embeds a Frame set to the caller's location and implements Formatter to show this information when printed with details.
Example ¶
package main
import (
"fmt"
"golang.org/x/exp/errors"
)
func main() {
err := errors.New("emit macho dwarf: elf header corrupted")
if err != nil {
fmt.Print(err)
}
}
Output: emit macho dwarf: elf header corrupted
Example (Errorf) ¶
The fmt package's Errorf function lets us use the package's formatting features to create descriptive error messages.
package main
import (
"fmt"
)
func main() {
const name, id = "bimmler", 17
err := fmt.Errorf("user %q (id %d) not found", name, id)
if err != nil {
fmt.Print(err)
}
}
Output: user "bimmler" (id 17) not found
Types ¶
type Formatter ¶
type Formatter interface {
error
// FormatError prints the receiver's first error and returns the next error in
// the error chain, if any.
FormatError(p Printer) (next error)
}
A Formatter formats error messages.
type Frame ¶
type Frame struct {
// contains filtered or unexported fields
}
A Frame contains part of a call stack.
type Printer ¶
type Printer interface {
// Print appends args to the message output.
Print(args ...interface{})
// Printf writes a formatted string.
Printf(format string, args ...interface{})
// Detail reports whether error detail is requested.
// After the first call to Detail, all text written to the Printer
// is formatted as additional detail, or ignored when
// detail has not been requested.
// If Detail returns false, the caller can avoid printing the detail at all.
Detail() bool
}
A Printer formats error messages.
The most common implementation of Printer is the one provided by package fmt during Printf. Localization packages such as golang.org/x/text/message typically provide their own implementations.
Source Files
Directories