Go学习之路（七）函数

与其它主要变成语言的差异

• 1. 可以有多个返回值
• 2. 所有参数都是值传递：slice，map，channel 会有传引用的错觉(比如切片,他背后对应的是一个数组,切片本身是一个数据结构,在这个数据结构中包含了指向了这个数组的指针,所以说,即便是在传值的情况下这个结构被复制到函数里了,在通过指针去操作这个数组的值的时候,其实是操作的是同一块空间,实际上是结构被复制了,但是结构里包含的指针指向的是同一个数组,所以才有这个错觉)
     所有的参数都是值传递:在go中的函数是把值拷贝了一份,在函数里操作并不会改变外面的值,用指针接受参数是把指针地址拷贝了一份,他
• 3. 函数可以作为变量的值
• 4. 函数可以作为参数和返回值
• 5. 不支持重载,一个包不能有两个名字一样的函数
• 6. 匿名函数
• 函数是一等公民: 参数, 变量, 返回值都可以是函数

值传递

把值拷贝了一份,优点不会改变外面的值

指针传递

拷贝了a的地址,函数内部很外部都是只想a,内部改变a,外部的值都会被改变

cache传递

cache拷贝了一份过去,只是把cache的指针拷贝了一份,当需要更改状态的时候需要用到指针传递

申明函数：
func 函数名(参数或多个参数 参数类型)(多个返回值的类型){}
func 函数名()单个返回值的类型{}
func 函数名(参数 ...参数类型)返回值类型{}
func(){}() 匿名函数

func a(){}     // 无参数,无返回值
func add(a,b int){} // 多参数,无返回值,两个同样类型的参数可以省略写一个
func add(a int,b int) {} 
func add(a,b int) int {}  //多参数,返回一个 int 型值
func add(a,b int) (int,int){} //多参数,返回多个 int 型值
func add(a ...int) int {}  // 可变参数,返回一个 int 型值
func () {}()   // 匿名函数

可变参数函数例子

可变长参数会被转化成一个数组，然后通过数组遍历来完成

package main
import (
  "testing"
  "fmt"
)
func add(a ...int) int{
  num:=0
  for _,res:=a{
    num+=res
  }
  return num
}
func TestNum(t *testing.T){
  num:=add(1,2,3,4,5,6)
  fmt.Println(num)
}

输出结果

21

用切片

package main
func add(a [8]int){        // 对值进行了拷贝,并不会改变S的值
  a[1]=200
  fmt.Println(a)
}

func sliceadd(a []int){       // 对
  a[0]=100
  fmt.Println(a)
}
func main(){
  s:=[...]int{0,1,2,3,4,5,6,7}
  add(s)
  fmt.Println(s)
  sliceadd(s[:])
  fmt.Println(s)
}

结果

0,200,3,4,5,6,7
0,1,2,3,4,5,6,7
100,1,2,3,4,5,6,7
100,1,2,3,4,5,6,7

defer 函数

延迟执行函数
defer 在函数执行完之后 return 前才执行
通常用于清理某些资源和处理某些异常
在一个函数中,如果有多个 defer 那它的执行顺序是从后往前执行

package main
import (
  "testing"
  "fmt"
)
func add(a ...int) int{
  num:=0
  for _,res:=a{
    num+=res
  }
  return num
}
func Clear(){
  fmt.Println("你好吗?")
}
func TestNum(t *testing.T){
  defer Clear()
  num:=add(1,2,3,4,5,6)
  fmt.Println(num)
}

运行结果

21
你好吗?

函数中有多个 defer 的例子

func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}

func TestFn(t *testing.T) {
    a := 1
    b := 2
    defer calc("1", a, b)
    a = 0
    defer calc("2", a, b)
    b = 1
}

运行结果

2 0 2 2
1 1 2 3

这是一道面试题

func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}

func TestFn(t *testing.T) {
    a := 1
    b := 2
    defer calc("1", a, calc("10", a, b))
    a = 0
    defer calc("2", a, calc("20", a, b))
    b = 1
}

运行结果

10 1 2 3
20 0 2 2
2 0 2 2
1 1 3 4

panic 程序异常中断,在go里面代表了不可修复的错误,在go中defer在panic之后也是会执行的

匿名函数

// 第一种
func main(){
  func(){
    fmt.Println("你好")
  }()
}
// 第二种 把匿名函数赋值给变量,然后执行变量
var f = func(){fmt.Println("你好")}
func main(){
  f()
}
// 第三种 把匿名函数赋值给变量,然后执行变量
func main(){
  f:=func(){fmt.Println("你好")}
  f()
}
// 带参数的匿名函数
func main(){
  func(str){
    fmt.Println(str)
  }("你好")
}

运行结果

你好

闭包函数

func timeSpent(inner func (op int) int) func (op int) int{
  return func(n int) int {
    start := time.Now()
    ret := inner(n)
    fmt.Println("time spent:", time.Since(start).Seconds())
    return ret
  }
}

timeSpent在这个闭包函数中传入的是一个函数 inner func(op int) int 相当于inner 的类型是func(opt int) int

package main
import "fmt"
func adder() func (int) int{
    sum:=0                                  // 自由变量
    return func(v int)int{              // v 是局部变量 这个匿名函数就是一个函数体
        sum+=v
        return sum      
    }
}

func main(){
    a := adder()
    for i :=0;i<10;i++{
        fmt.Println(a(i))
    }
}

adder 函数返回的时候返回的是个闭包
return func 返回的不是代码,返回是函数以及它的对sum的引用,sum会保存下来,保存到这个函数里面,

闭包函数实例

例子1:斐波那契数列

package main
import "fmt"

func fibonacci() func() int{
  a,b :=0,1
  return func() int{
    a,b = b,a+b
    return a
  }
}

func main(){
  f:=fibonacci()
  for i:=0;i<10;i++{
    fmt.Println(f())
  }
}

结果

1
1
2
3
5
8
13
21
34
55

例子二: 为函数实现接口

func fibonacci() intGen {
    a, b := 0, 1
    return func() int {
        a, b = b, a+b
        return a
    }
}

type intGen func() int

func (g intGen) Read(p []byte) (n int, err error) {
    next := g()
    if next > 100000 {
        return 0, io.EOF
    }
    s := fmt.Sprintf("%d\n", next)
    return strings.NewReader(s).Read(p)
}

func printFileContents(reader io.Reader) {
    scanner := bufio.NewScanner(reader)
    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }
}

func main() {
    f := fibonacci()

    printFileContents(f)


}