Returning errors in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return an error from the function.

Go

func check(value int) error {
    if value < 0 {
        return [1]("negative value")
    }
    return nil
}

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

Aerrors.New

Bpanic

Clog.Fatal

Dfmt.Println

Attempts:

3 left

💡 Hint

Common Mistakes

Using fmt.Println instead of returning an error.

Using panic which stops the program instead of returning an error.

The errors.New function creates a new error with the given message, which can be returned.

2fill in blank

medium

Complete the code to declare the function returns an error.

Go

func divide(a, b int) (int, [1]) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

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

Abool

Bint

Cerror

Dstring

Attempts:

3 left

💡 Hint

Common Mistakes

Returning string instead of error.

Not declaring the error return type.

The function returns an int and an error type to indicate success or failure.

3fill in blank

hard

Fix the error in the code to properly return an error.

Go

func openFile(name string) error {
    f, err := os.Open(name)
    if err != nil {
        return [1]
    }
    defer f.Close()
    return nil
}

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

Aerr

Bf

Cnil

Dos.Open

Attempts:

3 left

💡 Hint

Common Mistakes

Returning the file handle f instead of the error.

Returning nil when there is an error.

When os.Open returns an error, it should be returned directly as err.

4fill in blank

hard

Fill both blanks to create and return a formatted error message.

Go

func validate(age int) error {
    if age < 18 {
        return fmt.Errorf([1], [2])
    }
    return nil
}

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

A"age %d is too young"

Bage

C"error"

Dfmt.Errorf

Attempts:

3 left

💡 Hint

Common Mistakes

Using a plain string without formatting.

Not passing the age variable to format the message.

fmt.Errorf formats the error message with the age value.

5fill in blank

hard

Fill all three blanks to check error and handle it properly.

Go

result, err := divide(10, 0)
if [1] != nil {
    fmt.Println([2])
} else {
    fmt.Println([3])
}

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

Aerr

Cresult

Dnil

Attempts:

3 left

💡 Hint

Common Mistakes

Checking the wrong variable for error.

Printing the error in the else block.

Check if err is not nil to handle errors, otherwise print the result.

Practice

1.

What does a Go function return when there is no error?

easy

A. It returns nil as the error value.

B. It returns 0 as the error value.

C. It returns "no error" as the error value.

D. It returns an empty string "" as the error value.

Solution

1. Step 1: Understand Go error convention

   In Go, functions return an error type to indicate problems. If no problem occurs, the error is nil.

2. Step 2: Identify the correct no-error return value

   The standard way to show no error is to return nil, not zero, empty string, or text.

3. Final Answer:

   It returns nil as the error value. -> Option A

4. Quick Check:

   No error means error = nil [OK]

Hint: No error always returns nil, never zero or empty string [OK]

Common Mistakes:

• Returning 0 instead of nil for no error
• Returning empty string instead of nil
• Returning a string message instead of nil

2.

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

func example() ???

easy

A. func example() (int, error)

B. func example() int, error

C. func example() int error

D. func example() (int error)

Solution

1. Step 1: Recall Go function return syntax

   Go functions return multiple values by listing types in parentheses separated by commas.

2. Step 2: Match correct syntax

   The correct syntax for returning an int and error is (int, error). Other options miss commas or parentheses.

3. Final Answer:

   func example() (int, error) -> Option A

4. Quick Check:

   Multiple returns use parentheses and commas [OK]

Hint: Use parentheses and commas for multiple return types [OK]

Common Mistakes:

• Omitting parentheses for multiple returns
• Missing comma between return types
• Writing return types without parentheses

3.

What will be the output of this Go program?

package main
import (
  "errors"
  "fmt"
)
func divide(a, b int) (int, error) {
  if b == 0 {
    return 0, errors.New("division by zero")
  }
  return a / b, nil
}
func main() {
  result, err := divide(10, 0)
  if err != nil {
    fmt.Println(err)
  } else {
    fmt.Println(result)
  }
}

medium

A. runtime error

B. division by zero

C. 10

D. 0

Solution

1. Step 1: Analyze divide function behavior

   If divisor b is zero, function returns error with message "division by zero" and result 0.

2. Step 2: Check main function output

   Main calls divide(10, 0), gets error != nil, so prints the error message.

3. Final Answer:

   division by zero -> Option B

4. Quick Check:

   Error returned prints message [OK]

Hint: If error is not nil, print error message [OK]

Common Mistakes:

• Printing result even when error is not nil
• Expecting 0 as output instead of error message
• Assuming runtime panic on division by zero

4.

Identify the error in this Go function that returns an error:

func readFile(name string) (string, error) {
  data := ""
  file, err := os.Open(name)
  if err != nil {
    return data, err
  }
  defer file.Close()
  // read file content
  return data, nil
}

medium

A. Function should return only error, not string.

B. Return statement should return only data.

C. Defer statement should be before error check.

D. Missing import of os package.

Solution

1. Step 1: Check for required imports

   The function uses os.Open but does not import os package, causing a compile error.

2. Step 2: Verify other code parts

   Return types and defer placement are correct; only missing import is the problem.

3. Final Answer:

   Missing import of os package. -> Option D

4. Quick Check:

   Using os.Open requires importing os [OK]

Hint: Check imports when using standard library functions [OK]

Common Mistakes:

• Forgetting to import packages used
• Placing defer before error check
• Returning wrong number of values

5.

You want to write a Go function parseNumber that takes a string and returns an int and an error. It should return an error if the string is empty or not a valid number. Which implementation correctly returns errors?

func parseNumber(s string) (int, error) {
  if s == "" {
    return 0, errors.New("empty input")
  }
  n, err := strconv.Atoi(s)
  if err != nil {
    return 0, err
  }
  return n, nil
}

hard

A. Returns error only for invalid number, not empty string.

B. Returns nil error even if input is empty.

C. Correctly returns errors for empty and invalid input.

D. Returns zero and nil error for all inputs.

Solution

1. Step 1: Check empty string error handling

   The function returns error "empty input" if string is empty, which is correct.

2. Step 2: Check invalid number error handling

   Uses strconv.Atoi to convert string; returns error if conversion fails.

3. Step 3: Confirm success return

   If no error, returns parsed number and nil error.

4. Final Answer:

   Correctly returns errors for empty and invalid input. -> Option C

5. Quick Check:

   Empty and invalid inputs return errors [OK]

Hint: Return error immediately on invalid input [OK]

Common Mistakes:

• Not checking empty string before conversion
• Ignoring error from strconv.Atoi
• Returning nil error on invalid input