Error interface in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Error interface in Go?

The Error interface in Go is a built-in interface used to represent errors. It has a single method Error() string that returns a descriptive error message.

intermediate

How do you create a custom error type in Go?

You create a custom error type by defining a type and implementing the Error() string method for it. This makes your type satisfy the error interface.

beginner

What does the errors.New function do?

The errors.New function creates a simple error with a given message string. It returns a value that satisfies the error interface.

beginner

Why is it useful to use the error interface in Go functions?

Using the error interface allows functions to return detailed error information in a consistent way. It helps the caller handle errors gracefully and understand what went wrong.

beginner

What is the signature of the Error() method in the error interface?

The signature is Error() string. It returns a string describing the error.

What method must a type implement to satisfy the Go error interface?

A Error() int

B String() error

C Message() string

D Error() string

The error interface requires the method Error() string.

Which package provides the New function to create simple errors?

A errors

B io

C fmt

D strings

The errors package provides New to create basic error values.

What does the Error() method return?

A An integer error code

B A string describing the error

C Nothing (void)

D A boolean indicating success

The Error() method returns a string describing the error.

Why use the error interface instead of just strings for errors?

A To provide more structured error information

B Because strings are slower

C Because Go does not support strings

D To avoid using functions

The error interface allows more structured and flexible error handling than plain strings.

How do you check if a function returned an error in Go?

A if err == false

B if err == 0

C if err != nil

D if err == ""

In Go, errors are checked by comparing to nil: if err != nil means an error occurred.

Explain what the Go error interface is and why it is important.

Think about how Go functions communicate problems.

Describe how to create a custom error type in Go and why you might want to do that.

Consider when simple error messages are not enough.

Practice

1.

What does the Error() method in Go's error interface return?

easy

A. A boolean indicating success or failure

B. An integer error code

C. A string describing the error message

D. A pointer to the error object

Solution

1. Step 1: Understand the error interface

   The error interface in Go defines a single method Error() that returns a string.

2. Step 2: Identify the return type of Error()

   The Error() method returns a string that describes the error message.

3. Final Answer:

   A string describing the error message -> Option C

4. Quick Check:

   Error() returns string message [OK]

Hint: Error() always returns a string message describing the problem [OK]

Common Mistakes:

• Thinking Error() returns an integer code
• Assuming Error() returns a boolean
• Confusing Error() with returning an error object pointer

2.

Which of the following is the correct way to declare a function in Go that returns an error?

func doSomething() ???

easy

A. func doSomething() error

B. func doSomething() string

C. func doSomething() (int, error)

D. func doSomething() *error

Solution

1. Step 1: Recall function return types for errors

   In Go, functions that can fail often return an error type as the last return value.

2. Step 2: Check the syntax for returning only an error

   The correct syntax for a function returning only an error is func doSomething() error.

3. Final Answer:

   func doSomething() error -> Option A

4. Quick Check:

   Function returns error type only [OK]

Hint: Use 'error' as return type to indicate possible failure [OK]

Common Mistakes:

• Returning *error instead of error
• Returning string instead of error
• Returning multiple values without parentheses

3.

What will be the output of the following Go program?

package main
import (
	"errors"
	"fmt"
)
func main() {
	err := errors.New("file not found")
	if err != nil {
		fmt.Println(err.Error())
	} else {
		fmt.Println("No error")
	}
}

medium

A. file not found

B. No error

C. nil

D. Compilation error

Solution

1. Step 1: Understand errors.New usage

   The errors.New function creates a new error with the message "file not found".

2. Step 2: Check the if condition and output

   Since err is not nil, the program prints err.Error(), which is the string "file not found".

3. Final Answer:

   file not found -> Option A

4. Quick Check:

   Non-nil error prints message [OK]

Hint: errors.New creates error with message; err != nil prints message [OK]

Common Mistakes:

• Expecting 'No error' output
• Thinking err is nil after errors.New
• Confusing err.Error() with err itself

4.

Identify the error in this Go code snippet:

func check() error {
	var err error
	if err != nil {
		return err
	}
	return nil
}

medium

A. Missing parentheses in if condition

B. Variable err is never assigned, so err != nil is always false

C. Function must return a string, not error

D. Cannot return nil from a function returning error

Solution

1. Step 1: Analyze variable initialization

   The variable err is declared but never assigned a value, so it defaults to nil.

2. Step 2: Evaluate the if condition

   Since err is nil, the condition err != nil is false, so the return inside if never runs.

3. Final Answer:

   Variable err is never assigned, so err != nil is always false -> Option B

4. Quick Check:

   Unassigned error variable is nil [OK]

Hint: Uninitialized error is nil, so err != nil is false [OK]

Common Mistakes:

• Assuming err is non-nil by default
• Thinking function must return string
• Confusing nil return with error

5.

Given this Go function that returns an error, how can you modify it to wrap the original error with additional context?

func readFile() error {
	return errors.New("file missing")
}

Choose the best way to add context "readFile failed:" before the original error message.

hard

A. return fmt.Errorf("readFile failed: %v", errors.New("file missing"))

B. return errors.New("readFile failed: file missing")

C. return errors.Wrap(errors.New("file missing"), "readFile failed")

D. return fmt.Errorf("readFile failed: %w", errors.New("file missing"))

Solution

1. Step 1: Understand error wrapping in Go

   Go 1.13+ supports error wrapping using fmt.Errorf with the %w verb to wrap an error with context.

2. Step 2: Check options for wrapping

   return fmt.Errorf("readFile failed: %w", errors.New("file missing")) uses fmt.Errorf("readFile failed: %w", errors.New("file missing")), which correctly wraps the original error with context.

3. Step 3: Identify incorrect options

   return errors.New("readFile failed: file missing") creates a new error string but does not wrap the original error. return errors.Wrap(errors.New("file missing"), "readFile failed") uses errors.Wrap which is not in standard Go. return fmt.Errorf("readFile failed: %v", errors.New("file missing")) uses %v which formats but does not wrap the error.

4. Final Answer:

   return fmt.Errorf("readFile failed: %w", errors.New("file missing")) -> Option D

5. Quick Check:

   Use fmt.Errorf with %w to wrap errors [OK]

Hint: Use fmt.Errorf with %w to wrap errors and add context [OK]

Common Mistakes:

• Using %v instead of %w for wrapping
• Creating new error string without wrapping
• Using non-standard errors.Wrap function