Go Function Basics, Error Handling, and Advanced Features

Function Basics

In Go, functions are the basic building blocks of programs, allowing you to organize code into reusable logical units. The basic syntax for defining a function in Go is as follows:

func functionName(parameter1 type1, parameter2 type2) returnType {
    // function body
    return value
}

Simple Function Example

package main

import "fmt"

// Define an addition function
func add(a int, b int) int {
    return a + b
}

func main() {
    sum := add(3, 5)
    fmt.Println("3 + 5 =", sum) // Output: 3 + 5 = 8
}

Multiple Return Values

A notable feature of Go is support for multiple return values, which is especially useful in error handling:

func divide(a, b float64) (float64, error) {
    if b == 0.0 {
        return 0.0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

Named Return Values

Go allows naming return values; these variables are automatically initialized to the zero value of their type:

func rectangleProps(length, width float64) (area, perimeter float64) {
    area = length * width
    perimeter = 2 * (length + width)
    return // naked return, automatically returns area and perimeter
}

Error Handling

Go does not have an exception mechanism like other languages; instead it uses error return values to indicate problems. This is part of Go's philosophy: explicit error handling makes code clearer and more reliable.

Basic Error Handling Pattern

result, err := someFunction()
if err != nil {
    // handle error
    fmt.Println("发生错误:", err)
    return
}
// use result to continue normal flow

Custom Error Types

You can create custom error types to provide richer error information:

type MyError struct {
    Code    int
    Message string
}

func (e *MyError) Error() string {
    return fmt.Sprintf("错误 %d: %s", e.Code, e.Message)
}

func someOperation() error {
    return &MyError{Code: 404, Message: "资源未找到"}
}

defer Statement

The defer statement pushes function calls onto a list; when the current function returns, these calls are executed in LIFO order:

func readFile(filename string) (string, error) {
    file, err := os.Open(filename)
    if err != nil {
        return "", err
    }
    defer file.Close() // ensure the file is closed when the function returns

    content, err := ioutil.ReadAll(file)
    if err != nil {
        return "", err
    }

    return string(content), nil
}

panic and recover

Although not recommended for frequent use, Go provides panic and recover mechanisms to handle unrecoverable errors:

func safeDivide(a, b int) (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("运行时恐慌: %v", r)
        }
    }()

    if b == 0 {
        panic("除数不能为零")
    }

    return a / b, nil
}

Advanced Function Features

Functions as Values

In Go, functions are first‑class citizens and can be passed like other values:

func applyOperation(a, b int, operation func(int, int) int) int {
    return operation(a, b)
}

func main() {
    add := func(a, b int) int { return a + b }
    fmt.Println(applyOperation(3, 4, add)) // Output: 7
}

Closures

Go supports closures, allowing functions to access variables from their outer scope:

func counter() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}

func main() {
    c := counter()
    fmt.Println(c()) // 1
    fmt.Println(c()) // 2
    fmt.Println(c()) // 3
}

Variadic Functions

The ... syntax can define functions that accept a variable number of arguments:

func sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

func main() {
    fmt.Println(sum(1, 2, 3))       // 6
    fmt.Println(sum(1, 2, 3, 4, 5)) // 15
}

Best Practices

Error handling: always check for errors returned by functions.

Function length: keep functions short and focused on a single responsibility.

Naming conventions: use camelCase and choose clear, descriptive function names.

Documentation comments: add doc comments for public functions.

Parameter count: avoid too many parameters; consider using a struct.

By mastering Go's functions and error handling mechanisms, you can write well‑structured, robust Go programs. These fundamentals are the building blocks for more complex systems and are essential for becoming an efficient Go developer.