複数の戻り値と名前付き戻り値

In Go, a function can return multiple values. It's the mechanism that enables the (value, error) pattern you've already seen and that pervades the entire standard library.

Multiple returns

The return types go between parentheses, comma-separated:

func divmod(a, b int) (int, int) {
    return a / b, a % b
}

q, r := divmod(17, 5) // q=3, r=2

They are destructured with multiple assignment. To discard one of the values use _:

_, r := divmod(17, 5) // solo il resto

The canonical (T, error) pattern

Almost all of the stdlib follows it. error is ALWAYS last:

func read(path string) ([]byte, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("read %q: %w", path, err)
    }
    return data, nil
}

Named returns

You can name the return values: they become pre-declared variables initialized to zero, and return with no arguments returns them ("naked return"):

func divmod(a, b int) (q, r int) {
    q = a / b
    r = a % b
    return       // naked: ritorna q, r
}

Named returns also appear in documentation tooltips, so they're useful as a form of inline documentation for complex functions — not just for the naked return.

More than two returns?

Nothing stops you from (int, int, int, error), but if you feel the need it's almost always a sign that you should return a struct:

type Result struct {
    Sum  int
    Avg  float64
    Max  int
}

func analyze(nums []int) (Result, error) { ... }

Try it

func f() (a, b int) {
    a = 1
    b = 2
    return
}
x, y := f()
fmt.Println(x, y)

Recap

• Multiple values between parentheses: func f() (T1, T2, error).
• Convention: error ALWAYS as the last value; on error, zero value + error.
• Named returns pre-declare the variables and enable naked returns.
• Naked returns only in very short functions; beyond that, readability suffers.
• More than 2-3 returns? You probably want a struct.