Why error handling is required in Go - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why do we need error handling in Go?

Imagine you are writing a program that reads a file. Sometimes the file might not exist or be unreadable. Why is it important to handle such errors in Go?

A To ignore errors and continue running the program blindly

B To detect problems and respond properly, like showing a message or trying again

C To make sure the program crashes immediately without any message

D To slow down the program intentionally

💡 Hint

Think about what happens if the program tries to read a missing file without checking for errors.

Error handling lets the program know when something goes wrong. This way, it can fix the problem, warn the user, or stop safely instead of crashing or giving wrong results.

❓ Predict Output

intermediate

What is the output of this Go code with error handling?

Look at this Go code that tries to open a file. What will it print if the file does not exist?

Go

package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.Open("nofile.txt")
	if err != nil {
		fmt.Println("Error opening file:", err)
		return
	}
	defer file.Close()
	fmt.Println("File opened successfully")
}

A Error opening file: open nofile.txt: no such file or directory

B panic: runtime error

C No output

D File opened successfully

💡 Hint

What does the program do when err is not nil?

The program checks if there is an error opening the file. If the file does not exist, err is not nil, so it prints the error message and stops.

🔧 Debug

advanced

Identify the error handling mistake in this Go code

This Go code tries to read a file but has a mistake in error handling. What is the problem?

Go

package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.Open("data.txt")
	if err == nil {
		fmt.Println("Error opening file")
		return
	}
	defer file.Close()
	fmt.Println("File opened successfully")
}

A There is no mistake; the code is correct

B The file.Close() should not be deferred

C The error check is reversed; it should be 'if err != nil' instead of 'if err == nil'

D The program should panic instead of returning

💡 Hint

Remember, err is nil when there is no error.

The code wrongly treats err == nil as an error case. It should check if err != nil to detect errors.

📝 Syntax

advanced

Which option causes a compile-time error in Go error handling?

Which of these Go code snippets will cause a compile-time error?

A

file, err := os.Open("file.txt")
if err != nil {
	fmt.Println(err)
}

B

file, err := os.Open("file.txt")
if err != nil {
	fmt.Println(err)
} else {
	defer file.Close()
}

C

file, err := os.Open("file.txt")
if err != nil {
	fmt.Println(err)
} else {
	file.Close()
}

D

file, err := os.Open("file.txt")
if err != nil {
	fmt.Println(err)
}
else
	defer file.Close()

💡 Hint

Check the syntax rules for if-else statements and defer usage.

Option D misses braces for the else block with defer, causing a syntax error.

🚀 Application

expert

What is the value of 'result' after running this Go function with error handling?

Consider this Go function that divides two numbers and returns an error if dividing by zero. What is the value of 'result' after calling divide(10, 0)?

Go

package main

import (
	"errors"
	"fmt"
)

func divide(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("cannot divide by zero")
	}
	return a / b, nil
}

func main() {
	result, err := divide(10, 0)
	if err != nil {
		fmt.Println("Error:", err)
		result = -1
	}
	fmt.Println("Result:", result)
}

A Result: -1

B Result: 0

C Result: 10

D Program crashes with panic

💡 Hint

What happens when divide returns an error? How is 'result' changed?

The function returns an error and 0 when dividing by zero. The main function detects the error and sets result to -1 before printing.