Introduction

The aim of this tutorial is to provide a clear and concise introduction to error handling in Go. Go language treats errors as values and employs a unique approach to handle them. By the end of this tutorial, you will have a solid understanding of how to use the 'error' interface in Go and be able to handle errors effectively in your Go code.

The prerequisites for this tutorial are a basic understanding of programming concepts and familiarity with Go syntax.

Step-by-Step Guide

Understanding the 'error' Interface

In Go, an error is anything that implements the error interface. This interface consists of a single method, Error(), which returns a string.

type error interface {
    Error() string
}

Handling Errors

The idiomatic way to handle errors in Go is to compare the returned error to nil. If it is nil, the operation was successful. Otherwise, the operation failed, and the error variable contains information about what went wrong.

file, err := os.Open("non_existent_file.txt")
if err != nil {
    // handle the error here
    fmt.Println(err)
    return
}

In this case, if the file does not exist, os.Open will return an error.

Code Examples

Example 1: Basic Error Handling

package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("non_existent_file.txt")
    if err != nil {
        fmt.Println("Error opening file:", err)
        os.Exit(1)
    }
    fmt.Println(file)
}

In this example, the os.Open function is used to open a file. If the file does not exist, the function will return an error.

Example 2: Creating Custom Errors

package main

import (
    "errors"
    "fmt"
)

func main() {
    err := errors.New("My custom error")
    if err != nil {
        fmt.Println(err)
    }
}

In this example, we're using the errors.New function to create a new error with a custom message.

Summary

We've covered the basics of error handling in Go, including how to use the 'error' interface, handle errors, and create custom errors. To further your understanding, try experimenting with what you've learned in your own Go programs.

Practice Exercises

1. Write a Go program that reads a file and handles any errors that might occur. Try to handle different types of errors separately.

2. Create a custom error type that includes additional information, such as a timestamp of when the error occurred.

Reference: Go Documentation - Error Handling

Solutions

1. Reading a file in Go:

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    data, err := ioutil.ReadFile("file.txt")
    if err != nil {
        fmt.Println("File reading error", err)
        return
    }
    fmt.Println("Contents of file:", string(data))
}

1. Creating a custom error type:

package main

import (
    "fmt"
    "time"
)

type CustomError struct {
    When time.Time
    What string
}

func (e *CustomError) Error() string {
    return fmt.Sprintf("at %v, %s", e.When, e.What)
}

func main() {
    err := &CustomError{
        time.Now(),
        "it didn't work",
    }
    if err != nil {
        fmt.Println(err)
    }
}

In the second exercise, we've created a custom error type that has a timestamp of when the error occurred. This can be helpful when debugging errors in a large program.