Error interface in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the error interface method.

Go

type error interface {
	[1]() string
}

Drag options to blanks, or click blank then click option'

Aerror

BError()

CErrorString

DError

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase 'error' instead of 'Error' as method name.

Adding parentheses in the method name in the interface declaration.

The error interface requires a method named Error that returns a string.

2fill in blank

medium

Complete the code to implement the error interface for MyError type.

Go

type MyError struct {
	msg string
}

func (e MyError) [1]() string {
	return e.msg
}

Drag options to blanks, or click blank then click option'

AErrorString

Berror

CError

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'error' or 'String' instead of 'Error' as method name.

Forgetting to return a string.

The method to implement the error interface must be named Error and return a string.

3fill in blank

hard

Fix the error in the function signature to correctly implement the error interface.

Go

func (e *MyError) [1]() string {
	return e.msg
}

Drag options to blanks, or click blank then click option'

AError()

BError

Cerror

DErrorString

Attempts:

3 left

💡 Hint

Common Mistakes

Including parentheses in the method name in the declaration.

Using lowercase method name.

The method name must be exactly Error without parentheses in the declaration.

4fill in blank

hard

Fill both blanks to create a function that returns an error interface value.

Go

func NewError(msg string) [1] {
	return &[2]{msg}
}

Drag options to blanks, or click blank then click option'

Aerror

BMyError

Cmsg

Attempts:

3 left

💡 Hint

Common Mistakes

Returning concrete type instead of interface.

Not using pointer to struct.

The function returns the error interface type and returns a pointer to MyError struct initialized with the message.

5fill in blank

hard

Fill all three blanks to check if an error is nil and print its message.

Go

var err [1] = NewError("fail")
if err [2] nil {
	fmt.Println(err.[3]())
}

Drag options to blanks, or click blank then click option'

Aerror

B!=

CError

D*MyError

Attempts:

3 left

💡 Hint

Common Mistakes

Using pointer type instead of interface for error variable.

Using == instead of != to check error.

Calling method with wrong name or missing parentheses.

Declare err as type error, check if it is not nil, then call its Error() method to print the message.

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