函数
函数的定义
Go里面有两个保留的函数：init函数（能够应用于所有的package）和main函数（只能应用于package
main）。这两个函数在定义时不能有任何的参数和返回值。Go程序会自动调用init()和main()，所以你不需要在任何地方调用这两个函数。每个
package中的init函数都是可选的，但package
main就必须包含一个main函数。Go 一个非常特别的特性（对于编译语言而言）是函数和方法可以返回多个值
例：
package main
var a int
func main(){
s := Factorial(4)
println(s)
}
func Factorial(x int) (int) {
var result int
if x == 0 {
result = 1
} else {
result = x * Factorial(x - 1)
}
return result
}
输出结果：
24
也可以改为：
例：
package main
var a int
func main(){
s := Factorial(4)
println(s)
}
func Factorial(x int) (result int) {
if x == 0 {
result = 1
} else {
result = x * Factorial(x - 1)
}
return
}
输出结果：
24
延迟代码
func ReadWrite() bool {
file.Open("file")
// 做一些工作
if failureX {
file.Close()
return false
}
if failureY {
file.Close()
return false
}
file.Close()
return true
}
在这里有许多重复的代码。为了解决这些，Go 有了 defer 语句。在 defer 后指定的函数会在函数退出前调用。可改为如下代码：
func ReadWrite() bool {
file.Open("file")
defer file.Close() file.Close() 被添加到了 defer 列表
// 做一些工作
if failureX {
return false Close() 现在自动调用
}
if failureY {
return false 这里也是
}
return true
}
defer有点类似于PHP类中的__destruct()析构方法
defer也可以这样写：
defer func(x int) {/* ... */}(5)
为输入参数 x 赋值5
如果有很多调用defer，那么defer是采用后进先出模式，所以如下代码会输出 4 3 2 1 0
for i := 0; i < 5; i++ {
defer fmt.Printf("%d ", i)
}
例：
package main
var a int
func main(){
s := test(2)
println(s)
}
func test(i int) (t int){
defer func(){
t++
}()
t = i+1
return
}
输出结果：4
例2：
package main
var a int
func main(){
s := test(2)
println(s)
}
func test(i int) (t int){
defer func(x int){
t += x
}(5)
t = i+1
return
}
输出结果：8
注意：如果有很多调用defer,那么defer是采用后进先出模式
例3：
package main
func main(){
for j := 0; j < 5; j++ {
defer println(j)
}
}
输出结果：
4
3
2
1
0
变参
接受变参的函数是有着不定数量的参数的。为了做到这点，首先需要定义函数使其接受变参：
func myfunc(arg ...int) {}
arg ... int 告诉 Go 这个函数接受不定数量的参数。注意，这些参数的类型全部是 int。在函数体中，变量arg 是一个 int 类型的 slice
例：
package main
import "fmt"
func main(){
test("a", "b")
}
func test(arg ...string) {
for _, val := range arg{
fmt.Printf("%s\n",val)
}
}
输出结果：
a
b
函数作为值
上例也可以这样：
package main
import "fmt"
func main(){
demo := func(arg ...string) { //定义一个匿名函数，并且赋值给demo
for _, val := range arg{
fmt.Printf("%s\n",val)
}
}
demo("a", "b")
}
输出结果：
a
b
函数作为值也可以用在其他地方，如map。
例：
package main
import "fmt"
func main(){
map1 := map[int] func(i int) (int) {
1 : func(x int) (int) { return x+1 },
2 : func(y int) (int) { return y+2 },
3 : func(z int) (int) { return z+3 },
}
fmt.Printf("%d\n", map1[1](1))
fmt.Printf("%d\n", map1[2](1))
fmt.Printf("%d\n", map1[3](1))
}
输出结果：
2
3
4
回调函数
例：
package main
import "fmt"
func main(){
callback(2, printit)
}
func printit(x int){
fmt.Printf("%d\n", x)
}
func callback(y int, f func(int)){
f(y)
}
输出结果：2
例2：
package main
import "fmt"
func main(){
callback(2, printit)
}
func printit(x int)(demo int){
demo = x + 1
return
}
func callback(y int, f func(int)(int)){
result := f(y)
res := fmt.Sprintf("%d", result) + "demo" // Sprintf()将int转换成string
fmt.Printf("%s\n", res)
}
输出结果：
3demo
例3：
package main
import "fmt"
//简单的一个函数，实现了参数+1的操作
func add1(a *int) int { // 请注意，
*a = *a+1 // 修改了a的值
return *a // 返回新值
}
func main() {
x := 3
fmt.Println("x = ", x) // 应该输出 "x = 3"
x1 := add1(&x) // 调用 add1(&x) 传x的地址
fmt.Println("x+1 = ", x1) // 应该输出 "x+1 = 4"
fmt.Println("x = ", x) // 应该输出 "x = 4"
}
