如何使函数支持一两个返回值

in go tutorial following code is often seen:

a := foo()
b, c := foo()

or actually what I see is:

m["Answer"] = 48
a := m["Answer"]
v, ok := m["Answer"]

how many foo() is defined?

Is it two, one with one return type, another with two return type?

Or just one foo() with two return type defined, and somehow magically when only need one return value (a := foo()), another return value is omitted?

I tried

package main

func main() {
    a := foo()
    a = 1
}

func foo() (x, y int) {
    x = 1
    y = 2
    return
}

func foo() (y int) {
    y = 2
    return
}

But I got error message foo redeclared in this block

While some built in operations support both single and multiple return value modes (like reading from a map, type assertions, or using the range keyword in loops), this feature is not available to user defined functions.

If you want two versions of a function with different return values, you will need to give them different names.

The Effective Go tutorial has some good information on this.

Basically, a function defines how many values it returns with it's return statement, and it's function signature.

To ignore one or more of the returned values you should use the Blank Identifier, _(Underscore).

For example:

package main

import "fmt"

func singleReturn() string {
    return "String returned"
}

func multiReturn() (string, int) {
    return "String and integer returned", 1
}

func main() {
    s := singleReturn()
    fmt.Println(s)
    s, i := multiReturn()
    fmt.Println(s, i)
}

Playground

The v, ok := m["answer"] example you've given is an example of the "comma, ok" idiom (Also described in the Effective Go link above). The linked documentation uses type assertions as an example of it's use:

To extract the string we know is in the value, we could write:

str := value.(string)

But if it turns out that the value does not contain a string, the program will crash with a run-time error. To guard against that, use the "comma, ok" idiom to test, safely, whether the value is a string:

str, ok := value.(string)
if ok {
    fmt.Printf("string value is: %q
", str)
} else {
    fmt.Printf("value is not a string
")
}

If the type assertion fails, str will still exist and be of type string, but it will have the zero value, an empty string.