Why compare with errors.Is instead of == in Go?

Wrapping an error with fmt.Errorf and the %w verb nests the original inside a chain, so a direct == comparison against a sentinel like io.EOF or sql.ErrNoRows fails. errors.Is walks the whole chain and returns true if any wrapped error equals the target.

What is the difference between errors.Is and errors.As?

errors.Is checks whether the chain contains a specific sentinel value, returning a bool. errors.As searches the chain for an error of a given concrete type and, if found, assigns it to your variable so you can read its fields, such as the Offset on a *json.SyntaxError.

Is io.EOF an error condition I should log?

Usually not. io.EOF signals that a stream ended cleanly and is the normal way a read loop terminates. Treat it as a stop condition, not a failure, and only surface it when an EOF arrives mid-record, which is io.ErrUnexpectedEOF.

What does the %w verb do in fmt.Errorf?

The %w verb wraps an error inside a new one while preserving the original in the chain. This lets callers use errors.Is and errors.As to reach the underlying cause, unlike %v which only embeds the text and loses the type.

Is anything I search uploaded?

No. The full table and the search run entirely in your browser. Nothing you type is sent anywhere.

Go Standard Error Patterns

This is a searchable reference for Go’s standard error patterns — the canonical sentinel errors exported by the standard library (io.EOF, sql.ErrNoRows, context.Canceled), the concrete error types you inspect with errors.As (*os.PathError, *net.DNSError, *json.SyntaxError), and the errors/fmt helpers that tie them together.

How it works

Go errors are just values implementing the error interface, and the standard library distinguishes three families. Sentinel errors are exported package variables (io.EOF, fs.ErrNotExist, context.DeadlineExceeded) that you test against with errors.Is. Error types are concrete structs (*os.PathError, *strconv.NumError) carrying extra fields you extract with errors.As. Helpers — errors.New, fmt.Errorf with %w, errors.Is, errors.As, errors.Join — create and unwrap these.

The critical rule is that wrapping with fmt.Errorf("read config: %w", err) nests the original error in a chain. A bare err == io.EOF will then fail, while errors.Is(err, io.EOF) walks the chain and still matches. The same applies to types: errors.As(err, &pathErr) finds a *os.PathError no matter how deeply it is wrapped.

Example

Wrap once, then inspect through the chain:

data, err := io.ReadAll(r)
if err != nil {
    err = fmt.Errorf("read body: %w", err)   // wrap, keep the cause
}

if errors.Is(err, io.ErrUnexpectedEOF) {     // sentinel via chain
    // truncated input
}

var pathErr *os.PathError
if errors.As(err, &pathErr) {                // concrete type via chain
    log.Printf("op=%s path=%s", pathErr.Op, pathErr.Path)
}

Note that sql.ErrNoRows from QueryRow().Scan is a normal result meaning “not found”, not a failure — handle it explicitly with errors.Is rather than treating every non-nil error the same way. Everything runs in your browser; nothing is uploaded.

Go Standard Error Patterns

Email me this result

How it works

Example