package mainimport ("fmt"
)
import "errors"func Add(a int, b int) (ret int, err error) {if a < 0 || b < 0 { // 假设这个函数只支持两个非负数字的加法err = errors.New("Should be non-negative numbers!")return}return a + b, nil // 支持多重返回值
}func main() {res, err := _case.Add(1, 2)if err != nil {return}fmt.Println(res)
}

func Add(a, b int)(ret int, err error) { // ... 
}

func Add(a, b int) int { // ... 
}

import "mymath"// 假设Add被放在一个叫mymath的包中// ... 
c := mymath.Add(1, 2)

func myfunc(args ...int) { for _, arg := range args { fmt.Println(arg) } 
}// 这段代码的意思是，函数myfunc()接受不定数量的参数，这些参数的类型全部是int，
// 所以它可以用如下方式调用：myfunc(2, 3, 4) 
myfunc(1, 3, 7, 13)

package mainimport ("fmt"
)func processFunc(args ...int) {for i, _ := range args {args[i] += 1}fmt.Println(args)
}func myfunc(args ...int) {// 按照原样传递processFunc(args...)// 传递片段，实际上任意的int slice都可以传进去processFunc(args[1:]...)
}func main() {myfunc(2, 3, 4)
}

（3）任意类型的不定参数

func Printf(format string, args ...interface{}) { // ... 
}

用interface{}传递任意类型数据是Go语言的惯例用法。使用interface{}仍然是类型安全的，和C/C++不太一样

func MyPrintf(args ...interface{}) {for _, arg := range args {switch arg.(type) {case int:fmt.Println(arg, "is an int value.")case string:fmt.Println(arg, "is a string value.")case int64:fmt.Println(arg, "is an int64 value.")default:fmt.Println(arg, "is an unknown type.")}}
}func main() {var v1 int = 1var v2 int64 = 234var v3 string = "heheda"var v4 float32 = 1.234_case.MyPrintf(v1, v2, v3, v4)
}

（4）多返回值

与C、C++和Java等开发语言的一个极大不同在于，Go语言的函数或者成员的方法可以有多个返回值，这个特性能够让我们写出比其他语言更优雅，更简洁的代码。

比如File.Read()函数就可以同时返回读取的字节数和错误信息

如果读取文件成功，则返回值中的n为读取的字节数，err为nil，否则err为具体的出错信息：

func (file *File) Read(b []byte) (n int, err Error)

同样，从上面的方法原型可以看到，我们还可以给返回值命名，就像函数的输入参数一样。

• 返回值被命名之后，它们的值在函数开始的时候被自动初始化为空
• 在函数中执行不带任何参数的return语句时，会返回对应的返回值变量的值

Go语言并不需要强制命名返回值，但是命名后的返回值可以让代码更清晰，可读性更强，同时也可用于文档

如果调用方调用了一个具有多返回值的方法，但是却不想关心其中的某个返回值，可以简单地用一个下划线"_"来跳过这个返回值，比如下面的代码表示调用者在读文件的时候不想关心Read()函数返回的错误码：

n, _ := f.Read(buf)

（5）匿名函数与闭包

① 匿名函数是指不需要定义函数名的一种函数实现方式，匿名函数由一个不带函数名的函数声明和函数体组成，如下所示：

func NMFunc() {f := func(x, y int) int {return x + y}fmt.Println(f(1, 2)) // 输出: 3// 创建一个通道replyChan := make(chan int)// 启动一个新的 Goroutine，执行匿名函数，并向通道发送数据go func(ch chan int) {ch <- 42}(replyChan) // 花括号后直接跟参数列表，表示调用// 从通道接收数据ack := <-replyChan// 打印接收到的数据fmt.Println(ack) // 输出: 42// 关闭通道close(replyChan)
}

②闭包：Go的匿名函数是一个闭包

基本概念：闭包是可以包含自由（未绑定到特定对象）变量的代码块，这些变量不在这个代码块内或者任何全局上下文中定义，而是在定义代码块的环境中定义。要执行的代码块（由于自由变量包含 在代码块中，所以这些自由变量以及它们引用的对象没有被释放）为自由变量提供绑定的计算环境（作用域）。

闭包的价值：在于可以作为函数对象或者匿名函数

Go语言中的闭包：Go语言中的闭包同样会引用到函数外的变量，闭包的实现确保只要闭包还被使用，那么被闭包引用的变量会一直存在

closure.go

package main 
import ( "fmt" 
) 
func main() { var j int = 5 a := func()(func()) { var i int = 10 return func() { fmt.Printf("i, j: %d, %d\n", i, j) } }() a() j *= 2 a() 
}

上述例子的执行结果是：

i, j: 10, 5

i, j: 10, 10

type error interface { Error() string
}

func Foo(param int)(n int, err error) { // ... 
}

n, err := Foo(0) 
if err != nil { // 错误处理
} else { // 使用返回值n 
}

func (e *PathError) Error() string { return e.Op + " " + e.Path + ": " + e.Err.Error() 
}

package mainimport ("fmt""os"
)// PathError 自定义错误类型
type PathError struct {Op   stringPath stringErr  error
}// 实现 error 接口的 Error 方法
func (e *PathError) Error() string {return e.Op + " " + e.Path + ": " + e.Err.Error()
}// 函数用来模拟文件操作，并返回一个自定义的 PathError 错误
func simulateFileOperation() error {// 尝试获取文件信息，这里故意对一个不存在的文件操作_, err := os.Stat("a.txt")if err != nil {// 返回自定义的 PathError 错误return &PathError{Op:   "stat",Path: "a.txt",Err:  err,}}return nil
}func main() {// 调用模拟文件操作的函数err := simulateFileOperation()if err != nil {// 把错误断言为 *PathError 类型if e, ok := err.(*PathError); ok && e.Err != nil {// 获取 PathError 类型变量 e 中的其他信息并处理fmt.Printf("Operation: %s\n", e.Op)fmt.Printf("Path: %s\n", e.Path)fmt.Printf("Error: %s\n", e.Err)fmt.Printf("Full Error: %s\n", e.Error())} else {// 其他类型的错误fmt.Println(err)}} else {// 文件操作成功fmt.Println("File operation succeeded")}
}

Operation: stat
Path: a.txt
Error: stat a.txt: no such file or directory
Full Error: stat a.txt: stat a.txt: no such file or directory