main.go:

package main

import (
    "fmt"
    "time"
)

// 函数：有多个输入参数，一个输出参数
func add(a int, b int) int {
    return a + b
}

// 函数：输入参数为空，输出参数为空
func Print() {
    println("hello world")
}

// 函数：输入参数为空，有输出参数
func Format(t *time.Time) string {
    return t.Format("2006-01-02 15:04:05")
}

// 函数：从函数体中返回一个指针对象
func Now() *time.Time {
    now := time.Now()
    return &now
}

type Person struct{}

// 类的成员函数: 指针接收器
func (p *Person) Run() {
    println("do something...")
}

// 类的成员函数: 值接收器
func (p Person) Run2() {
    println("do something...")
}

// 函数：结构体值参数
func RunPerson(p Person) {
    p.Run()
}

// 函数：结构体指针参数
func RunPerson2(p *Person) {
    p.Run()
}

type Runner interface {
    Run() // 接口方法申明
}

// 泛型函数
func MyFunc[T Runner](x T) {
    x.Run()
}

// 函数：多返回值
func f2() (int, int) {
    return 1, 2
}

// 函数：函数作为入参
func f3(f func()) {
    f()
}

// 函数：函数作为返回值
func f4() func() bool {
    return func() bool {
        return true
    }
}

// 通常使用最后一个输出参数返回error
func f5(i int) error {
	if i < 0 {
		return errors.New("invalid i")
	}
	return nil
}

// 通常使用最后一个输出参数返回error
func f6(i int) (int, error) {
	if i < 0 {
		return 0, errors.New("invalid i")
	}
	return 10, nil
}

// 递归函数
func factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * factorial(n-1)
}

// 主函数
func main() {
    // 闭包函数的定义与使用
    f := func(i int) {
        println("i:", i)
    }
    f(10)

    // 函数：多返回值调用
    i1, _ := f2()
    fmt.Printf("i1:%v\n", i1)

    println("done.")
}

说明：

1. golang中使用func定义函数，函数可以有0或者多个入参，也可以有0或者多个输出参数
2. 函数名的首字母大写代表public，其他代表package(包可见性)
3. golang中函数参数没有默认值，没有命名参数，python和仓颉等语言有。
4. golang中函数可以返回类似元组的多值，这一点挺好的。/通常会使用最后一个输出参数返回error，这是一种编码范式吧
5. 因为golang是支持GC的，所以可以从一个函数体中返回一个变量指针，该变量对应的数据在不再使用后，会被GC自动回收
6. golang中函数作为一种数据类型，本身可以被变量定义，被参数传递。函数类型是引用类型。
7. golang支持闭包(匿名函数)，同样的匿名函数可以被当作变量做参数传递
8. 类的成员函数，可以使用指针接收器，也可以使用值接收器。
9. 函数支持泛型处理
10. main是一个应用的主入口函数.