go语言之函数及闭包

一：函数

1 概述：

函数是 Go 程序源代码的基本构造单位，一个函数的定义包括如下几个部分，函数声明关键字 也町、 函数名、参数列表、返回列表和函数体。
函数名遵循标识符的命名规则， 首字母的大小写决定该函数在其他包的可见性：大写时其他包可见，小写时只有相同的包可以访问；

func 函数名 (参数列表) (返回值列表) {
        函数体
}        

2 特点

函数声明的格式

方法名首字母大写是public，方法名首字母小写private私有方法

1）函数类型

package main

import (
    "fmt"
)
//1 无参无返回值
func test(){
    fmt.Println("三无产品")
}
//2 有参无返回值
func test1(v1 int,v2 int){
    fmt.Println(v1,v2)
}
//3 有不定参数无返回值
func test2(args ...int){
    for _,n :=range args{
        fmt.Println(n)
    }
}

//调用以上函数
func main(){
    test()
    test1(,)
    test2(,,,)
}

package main

import "fmt"

//无参有返回值
func test4(a int ,str string){
	a = 666
	str= "我是沙雕"
	return
}
func test5() (int,string){
	return 250,"字符串"
}
func main(){
	a,str := test4()  //test4没有返回值，运行会报错
	fmt.Println(a,str)
	_,s :=test5()
	fmt.Println(s)
}

package main

import (
    "fmt"
)
//有参有返回值
//求两个数的最大值和最小值
func test1(num1 int,num2 int) (min int,max int){
    if num1>num2{
        min=num2
        max=num1
    }else {
        max=num2
        min=num1
    }
    return
}
func main(){
    min,max := test1(,)
    fmt.Println(min,max)
}

求1~100的和代码实现两种方法

package main

import "fmt"
//循环实现1到100累加
func test01() int {
    sum :=
    for i :=;i<=;i++{
        sum +=i
    }
    return sum
}
//递归实现1到100的累加
func test02(num int)int{
    if num=={
        return
    }
    return num +test02(num-)
}

func main()  {
    fmt.Println(test01())
    fmt.Println(test02())
}

2）注意：

(） 有参无返回值 ，参数名就相当于函数体内层的局部变量，命名返回值变量会被初始化类型零值
(）不支持默认值参数。
(）不支持函数重载。
(）不支持函数嵌套，严格地说是不支持命名函数的嵌套定义，但支持嵌套匿名函数

3 多值返回

func   swap(a,b int) (int,int){
         return  b,a
}

4 实参到形参的传递

package  main
import "fmt"
func chvalue(a int) int{
    a=a+
    return a
}
func chpointer(a *int){
    *a = *a +
    return
}
func main()  {
    a :=
    chvalue(a)   //实参传递给形参是值拷贝
    fmt.Println(a)

    chpointer(&a) //实参传递给形参然仍是值拷贝，只不过复制的是a的地址值
    fmt.Println(a)
}

5 不定参数

不定参数声明使用 （参数 .. . type） 的语法格式

特点：

() 所有的不定参数类型必须是相同的
(）不定参数必须是函数的最后一个参数。
(）不定参数名在函数体 内相当于切片，对切片的操作同样适合对不定参数的操作

package main
func sum(arr ...int)(sum int){
    for _, v := range arr{   //arr相当于切片
        sum += v
    }
    return
}

6 切片可以作为参数传递给不定参数，切片名后要加上 ”...“

package main

//import "go/types"

func sum(arr ...int)(sum int){
    for _,v :=range arr{
        sum += v
    }
    return
}
func main()  {
    slice := []int{,,,}
    array := [...]int{,,,}
    //数组不可以作为实参传递给不定参数的函数 所以sum(array...）会报错  cannot use array (type [4]int) as type []int in argument to sum
    sum(slice...)
}

7  形参为不定参数的函数的函数和形参为切片的函数类型不相同

package main

import (
    "fmt"
)

func suma(arr ...int)(sum int){
    for  v := range arr{
        sum += v
    }
    return
}

func sumb(arr []int) (sum int)  {
    for v := range arr{
        sum += v
    }
    return
}
func main()  {
    //suma 和sumb的类型不一样
    fmt.Printf("%T\n",suma)
    fmt.Printf("%T\n",sumb)
}

8  函数签名

概述：

函数类型又 函数签名 个函 类型就是函数定义首行去掉函数名、参数名和｛，可以
使用台nt.Printf 的”%T”格式化参数打印函数的类型。

package main

import "fmt"

func add(a,b int) int {
    return  a + b
}
func main()  {
    fmt.Printf("%T\n",add)   //打印效果 func(int, int) int
}

两个函数类型相同的条件是：拥有相同的形参列表和返回值列表（列表元素的次序、个数和类型相同）形参名可以不同

func add(a,b int) int { return a+b)
func sub (x int, y int) (c int) { c=x- y ; return c ) 

可以使用 type 定义函数类型，函数类型变量可以作为函数的参数或返

package main
import "fmt"
func add(a,b int) int {
    return a + b
}
func sub(a,b int) int {
    return a - b
}
type Op func(int,int) int //定义一个函数类型，输入的是两个int类型
                            //返回值是一个int类型
func do(f Op,a,b int) int  {  //定义一个函数，第一个参数是函数类型Op
    return f(a,b)         //函数类型变量可以直接用来进行函数调用
}
func main(){
    a := do(add,,)        //函数名add可以当作相同函数类型的形参
    fmt.Println(a)                   //
    s := do(sub,,)
    fmt.Println(s)                  //-1
}

总结：

 实际函数类型变 和函数名都可以当作指针变量，该指针指向函数代码开始位置 通常说函数类型变量是一
种引用类型，未初始化的函数类型变量的默认值是nil
 有名函数的函数名可以看作函数类型的常 ，可以
直接使用函数名调用函数，也可以直接赋值给函数类型变量，

package main

func sum(a,b int) int{
    return a + b
}
func main(){
    sum(,)  //直接调用
    f := sum        //有名函数可以直接赋值给变脸
    f(,)
}

9  匿名函数

Go 提供两种函数 有名函数和匿名函数。匿名函数可以看作函数字面量 所有直接使用函
数类型变量的地方都可以由匿名函数代替。医名函数可以直接赋值给函数变量，可以当作实参，
也可以作为返回值，还可以直接被调用

package main

import "fmt"

//匿名函数被直接赋值函数变量
var sum = func(a,b int) int {
    return a + b
}

func doinput(f func(int,int) int,a,b int)  {
    return
}

//匿名函数作为返回值
func wrap(op string) func(int, int) int{
    switch op {
    case "add":
        return func(a int, b int) int {
            return a +b
        }
    case "sub":
        return func(a int, b int) int {
            return  a + b
        }
    default:
        return nil
    }
}
func  main() {
    //匿名函数被直接调用
    defer func() {
        if err :=recover();err !=nil{
            fmt.Println(err)
        }
    }()
    sum(,)
    //匿名函数作为实参
    doinput(func(x , y int) int {
        return  x + y
    },,)
    opFunc :=wrap("add")
    re := opFunc(,)
    fmt.Printf("%d\n",re)
    fmt.Println(f)
}

二 ： defer关键字

使用
Go 函数里提供了 defe 关键字，可以注册多个延迟调用，这些调用以先进后出（ FILO ）的
顺序在函数返回前被执行

package main

import "fmt"

func test(x int){
    fmt.Println(/x)
}
func main()  {
    //defer 是延迟操作
    defer fmt.Println("aaa")
    defer fmt.Println("bbb")
    //报错并不影响程序的运行
    defer test()
    defer fmt.Println("ccc")
}

注意 ：

  defer 后面必须是函数或方法的调用，不能是语句，否则会报
 express on in defer must be function call 错误。
 defer 函数的实参在注册时通过值拷贝传递进去。

package main
func f() int{
    a :=
    defer func(i int) {
        println("defer i=",i)  //defer i= 0
    }(a)
    a++
    return a
}
func main()  {
    f()
}
//注：实参a 的值在defer注册时通过值拷贝传递进去，后续语句a++不会影响defer语句最后输出结果

 defer语句必须先注册后才能执行，如果defer位于return之后，则defer因为没有注册，不会执行

package main

func main(){
	defer func() {
		println("first")
	}()
	a := 0
	println(a)  //0
	return

	defer func() {
		println("second")   //first
	}()
}

 defer的好处是可以在一定程度上避免资源泄漏，特别是在有很多return语句，有多个资源需要关闭的场景，
很容易漏掉资源关闭操作

func CopyFile (dst , src string) (w int64 , err error) {
    src , err := os.Open(src)
    if err != nil {
    return
    }
    dst, e rr := os . Create(dst)
    if err != nil {
    //src 很容易忘记关闭
    src.Close ()
        returη
    }
    w, err ＝工 Copy dst src )
    dst.Close()
    src.Close ()
    return
}

　　在打开资源无报错后直接调用 defer 关闭资源

func CopyFile (dst , src string) (w nt64 err error) {
    src , err := os.Open (src )
    if err != nil {
    return
    }
    defer src . Close()
    dst , err := os . Create(dst)
    if err != nil {
        return
    }
    defer dst. Close ()
    w, err ＝工 Copy(dst src)
    return
}
//总结 1defer 语句的位置不当，有可能导致 panic 一般 def1 语句放在错误检查语句之后。
//2defer 也有明显的副作用： defer 会推迟资源的释放， defer 尽量不要放到循环语句里面，将大函数内部的defer语句单独拆分成
//一个小函数是一种很好的实践方式。另外， defer 相对于普通的函数调用需要间接的数据结构的支持，相对于普通函数调用有一定的性能损耗
//3 defer r 中最好不要对有名返回值参数进行操作 

四 ：闭包

 概述：
闭包是由函数及其相关引用环境组合而成的实体，一般通过在匿
名函数中引用外部函数的局部变量或包全局变构成。
 引用：闭包＝函数＋引用环境
详解：
闭包对闭包外的环境引入是直接引用，编译器检测到闭包，会将闭包引用的外部变量分配到堆上
如果函数返回的闭包引用了该函数的局部变量（ 参数或函数内部变量〉
(）多次调用该函数，返回的多个闭包所引用的外部变量是多个副本，原因是每次调用函
数都会为局部变量分配内存
(）用一个闭包函数多次，如果该闭包修改了其引用的外部变量，则每一次调用该闭包对
该外部变量都有影响，因为闭包函数共享外部引用。

示例：

package main

func fa(a int) func(i int) int{
    return func(i int) int {
        println(&a,a)
        a= a+i
        return a
    }
}
func main(){
    f :=fa()  //f 引用的外部的闭包环境包括本次函数调用的形参a的值1
    g := fa() //g 引用的外部的闭包环境包括本次函数调用的形参a的值1
    //此时f、g引用的闭包环境中的a的值并不是同一个，而是两次函数调用产生的副本
    println(f())      //0xc00006c000 1       2
    //多次调用f引用的同一个副本a
    println(f())      //0xc00006c000 2       3
    //g中a的值然仍是1
    println(g())      //0xc00006c008 1        2
    println(f())      //0xc00006c000 3        4
}
//f和g引用的是不同的a

（3）如果函数返回的闭包引用的是全局变量 ，则多次调用该函数返回的多个闭包引用的都是同一个a。
同理，调用 个闭包多次引用的也是同一个 。此时如果闭包中修改了a 值的逻辑，
每次闭包调用都会影响全局变量 的值。

示例：

package main

var(
    a=
)

func fa() func(i int) int  {
    return func(i int) int {
        println(&a,a)
        a = a +i
        return a
    }
}
func main()  {
    f :=fa()  //f 引用的外部的闭包环境包括全局交量a
    g :=fa()  //f 引用的外部的闭包环境包括全局变量a
    //／此时f、g 引用的闭包环境中的a 的值是同一个
    println(f())     //0x4d68b8 0      1
    println(g())     //0x4d68b8 0      2
    println(g())     //0x4d68b8 0      3
    println(g())     //0x4d68b8 0      4
}

　　（4）同一个函数返回的多个闭包共享该函数的局部

package main

func fa(base int) (func(int) int,func(int) int) {
    print(&base,base)    //0xc00006c00000xc00006c00800xc00006c000 1
    add := func(i int)  int {
        base += i
        println(&base,base)
        return base
    }
    sub := func(i int) int{
        base -= i
        println(&base,base)
        return base
    }
    return add,sub
}
func main() {
    //f、g 闭包引用的 base 是同一个，是fa函数调用传递过来的实参值
    f,g := fa()
    //s、k 包引用的base是同一个是fa函数调用传递过来的实参值
    s,k := fa()
    //f、g和s、k 引用不同的闭包交量，这是由于fa每次调用都妥重新分配形参
    println(f())
    println(g())
    println(s())
    println(k())
}