Error interface in Go - Mini Project: Build & Apply

Understanding the Error Interface in Go

📖 Scenario: Imagine you are building a simple program that checks if a user is old enough to vote. If the user is too young, the program should return an error message.

🎯 Goal: You will create a custom error using Go's error interface, check the user's age, and print the error message if the user is not old enough.

📋 What You'll Learn

Create a custom error type that implements the Error() method

Write a function checkAge that returns an error if age is less than 18

Call checkAge with a specific age and handle the error

Print the error message if an error occurs

💡 Why This Matters

🌍 Real World

Custom errors help programs give clear messages when something goes wrong, like invalid user input.

💼 Career

Understanding error handling is essential for writing reliable Go programs used in backend services and tools.

1

Create a custom error type

Create a struct called AgeError with a field message of type string.

Go

# Your code here
// Create a struct called AgeError with a string field message

Hint

Use type AgeError struct { message string } to define the struct.

2

Implement the Error() method

Add a method Error() to AgeError that returns the message field as a string.

Go

package main

type AgeError struct {
    message string
}

// Add the Error() method to AgeError
# Your code here

Hint

The method signature should be func (e AgeError) Error() string and return e.message.

3

Write the checkAge function

Write a function called checkAge that takes an age of type int and returns an error. If age is less than 18, return an AgeError with the message "Age is less than 18". Otherwise, return nil.

Go

package main

type AgeError struct {
    message string
}

func (e AgeError) Error() string {
    return e.message
}

// Write the checkAge function below
# Your code here

Hint

Use an if statement to check the age and return the custom error or nil.

4

Call checkAge and print the error

In the main function, call checkAge with the value 16. If an error is returned, print the error message using fmt.Println(err).

Go

package main

import "fmt"

type AgeError struct {
    message string
}

func (e AgeError) Error() string {
    return e.message
}

func checkAge(age int) error {
    if age < 18 {
        return AgeError{message: "Age is less than 18"}
    }
    return nil
}

func main() {
    // Call checkAge with 16 and print error if any
    # Your code here
}

Hint

Use err := checkAge(16) and then check if err != nil to print the error.

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