Error interface in Go - Time & Space Complexity

Time Complexity: Error interface

O(n)

Understanding Time Complexity

When working with the error interface in Go, it's important to understand how the program's steps grow as it handles errors.

We want to see how the time to check or create errors changes as the program runs.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

func checkErrors(errors []error) {
    for _, err := range errors {
        if err != nil {
            println(err.Error())
        }
    }
}
    

This code goes through a list of errors and prints the message for each non-nil error.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through the slice of errors.
• How many times: Once for each error in the list.

How Execution Grows With Input

As the number of errors increases, the program checks each one in turn.

Input Size (n)	Approx. Operations
10	About 10 checks and possible prints
100	About 100 checks and possible prints
1000	About 1000 checks and possible prints

Pattern observation: The work grows directly with the number of errors.

Final Time Complexity

Time Complexity: O(n)

This means the time to check errors grows in a straight line with the number of errors.

Common Mistake

[X] Wrong: "Checking errors is instant and does not depend on how many errors there are."

[OK] Correct: Each error must be checked one by one, so more errors mean more work.

Interview Connect

Understanding how error handling scales helps you write clear and efficient code, a skill valued in real projects and interviews.

Self-Check

"What if we stored errors in a map instead of a slice? How would the time complexity change when checking for errors?"

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