「这是我参与2022首次更文挑战的第6天，活动详情查看：2022首次更文挑战」

1. 函数

1.1 什么是函数

函数是执行特定任务的代码块。

1.2 函数的声明

go语言至少有一个main函数语法格式：

func funcName(parametername type1, parametername type2) (output1 type1, output2 type2) {
//这里是处理逻辑代码
//返回多个值
return value1, value2
}

func：函数由 func 开始声明
funcName：函数名称，函数名和参数列表一起构成了函数签名。
parametername type：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
output1 type1, output2 type2：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
上面返回值声明了两个变量output1和output2，如果你不想声明也可以，直接就两个类型。
如果只有一个返回值且不声明返回值变量，那么你可以省略包括返回值的括号（即一个返回值可以不声明返回类型）
函数体：函数定义的代码集合。

1.3 函数的使用

示例代码：

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 100
   var b int = 200
   var ret int

   /* 调用函数并返回最大值 */
   ret = max(a, b)

   fmt.Printf( "最大值是 : %d\n", ret )
}

/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {
   /* 定义局部变量 */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

运行结果：

最大值是 : 200

2. 函数的参数

2.1 参数的使用

形式参数：定义函数时，用于接收外部传入的数据，叫做形式参数，简称形参。

实际参数：调用函数时，传给形参的实际的数据，叫做实际参数，简称实参。

函数调用：

A：函数名称必须匹配

B：实参与形参必须一一对应：顺序，个数，类型

2.2 可变参

Go函数支持变参。接受变参的函数是有着不定数量的参数的。为了做到这点，首先需要定义函数使其接受变参：

func myfunc(arg ...int) {}

arg ...int告诉Go这个函数接受不定数量的参数。注意，这些参数的类型全部是int。在函数体中，变量arg是一个int的slice：

for _, n := range arg {
fmt.Printf("And the number is: %d\n", n)
}

2.3 参数传递

go语言函数的参数也是存在值传递和引用传递 函数运用场景 值传递

package main

import (
   "fmt"
   "math"
)

func main(){
   /* 声明函数变量 */
   getSquareRoot := func(x float64) float64 {
      return math.Sqrt(x)
   }

   /* 使用函数 */
   fmt.Println(getSquareRoot(9))

}

引用传递
这就牵扯到了所谓的指针。我们知道，变量在内存中是存放于一定地址上的，修改变量实际是修改变量地址处的内存。只有add1函数知道x变量所在的地址，才能修改x变量的值。所以我们需要将x所在地址&x传入函数，并将函数的参数的类型由int改为*int，即改为指针类型，才能在函数中修改x变量的值。此时参数仍然是按copy传递的，只是copy的是一个指针。请看下面的例子

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"
}

传指针使得多个函数能操作同一个对象。
传指针比较轻量级 (8bytes),只是传内存地址，我们可以用指针传递体积大的结构体。如果用参数值传递的话, 在每次copy上面就会花费相对较多的系统开销（内存和时间）。所以当你要传递大的结构体的时候，用指针是一个明智的选择。
Go语言中slice，map这三种类型的实现机制类似指针，所以可以直接传递，而不用取地址后传递指针。（注：若函数需改变slice的长度，则仍需要取地址传递指针）

3. 函数的返回值

3.1 什么是函数的返回值

一个函数被调用后，返回给调用处的执行结果，叫做函数的返回值。

调用处需要使用变量接收该结果

3.2 一个函数可以返回多个值

一个函数可以没有返回值，也可以有一个返回值，也可以有返回多个值。

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}
func SumAndProduct(A, B int) (add int, Multiplied int) {
add = A+B
Multiplied = A*B
return
}

3.3 空白标识符

_是Go中的空白标识符。它可以代替任何类型的任何值。让我们看看这个空白标识符的用法。

比如rectProps函数返回的结果是面积和周长，如果我们只要面积，不要周长，就可以使用空白标识符。

示例代码:

package main

import (  
    "fmt"
)

func rectProps(length, width float64) (float64, float64) {  
    var area = length * width
    var perimeter = (length + width) * 2
    return area, perimeter
}
func main() {  
    area, _ := rectProps(10.8, 5.6) // perimeter is discarded
    fmt.Printf("Area %f ", area)
}

4. 函数中变量的作用域

作用域：变量可以使用的范围。

4.1 局部变量

一个函数内部定义的变量，就叫做局部变量
变量在哪里定义，就只能在哪个范围使用，超出这个范围，我们认为变量就被销毁了。

4.2 全局变量

一个函数外部定义的变量，就叫做全局变量
所有的函数都可以使用，而且共享这一份数据

5. defer

5.1 延迟是什么?

即延迟（defer）语句，延迟语句被用于执行一个函数调用，在这个函数之前，延迟语句返回。

5.2 延迟函数

你可以在函数中添加多个defer语句。当函数执行到最后时，这些defer语句会按照逆序执行，最后该函数返回。特别是当你在进行一些打开资源的操作时，遇到错误需要提前返回，在返回前你需要关闭相应的资源，不然很容易造成资源泄露等问题

如果有很多调用defer，那么defer是采用后进先出模式
在离开所在的方法时，执行（报错的时候也会执行）

func ReadWrite() bool {
    file.Open("file")
    defer file.Close()
    if failureX {
          return false
    } 
    if failureY {
          return false
    } 
    return true
}

最后才执行file.Close()

示例代码：

package main

import "fmt"

func main() {
    a := 1
    b := 2
    defer fmt.Println(b)
    fmt.Println(a)
}

运行结果：

1
2

示例代码：

package main

import (  
    "fmt"
)

func finished() {  
    fmt.Println("Finished finding largest")
}

func largest(nums []int) {  
    defer finished()    
    fmt.Println("Started finding largest")
    max := nums[0]
    for _, v := range nums {
        if v > max {
            max = v
        }
    }
    fmt.Println("Largest number in", nums, "is", max)
}

func main() {  
    nums := []int{78, 109, 2, 563, 300}
    largest(nums)
}

运行结果：

Started finding largest  
Largest number in [78 109 2 563 300] is 563  
Finished finding largest

5.3 延迟方法

延迟并不仅仅局限于函数。延迟一个方法调用也是完全合法的。让我们编写一个小程序来测试这个。

示例代码：

package main

import (  
    "fmt"
)

type person struct {  
    firstName string
    lastName string
}

func (p person) fullName() {  
    fmt.Printf("%s %s",p.firstName,p.lastName)
}

func main() {  
    p := person {
        firstName: "John",
        lastName: "Smith",
    }
    defer p.fullName()
    fmt.Printf("Welcome ")  
}

运行结果：

Welcome John Smith

5.4 延迟参数

延迟函数的参数在执行延迟语句时被执行，而不是在执行实际的函数调用时执行。

让我们通过一个例子来理解这个问题。

示例代码：

package main

import (  
    "fmt"
)

func printA(a int) {  
    fmt.Println("value of a in deferred function", a)
}
func main() {  
    a := 5
    defer printA(a)
    a = 10
    fmt.Println("value of a before deferred function call", a)

}

运行结果：

value of a before deferred function call 10  
value of a in deferred function 5

5.5 堆栈的推迟

当一个函数有多个延迟调用时，它们被添加到一个堆栈中，并在Last In First Out（LIFO）后进先出的顺序中执行。

我们将编写一个小程序，它使用一堆defers打印一个字符串。示例代码：

package main

import (  
    "fmt"
)

func main() {  
    name := "Naveen"
    fmt.Printf("Orignal String: %s\n", string(name))
    fmt.Printf("Reversed String: ")
    for _, v := range []rune(name) {
        defer fmt.Printf("%c", v)
    }
}

运行结果：

Orignal String: Naveen  
Reversed String: neevaN

5.6 defer注意点

当外围函数中的语句正常执行完毕时，只有其中所有的延迟函数都执行完毕，外围函数才会真正的结束执行。
当执行外围函数中的return语句时，只有其中所有的延迟函数都执行完毕后，外围函数才会真正返回。
当外围函数中的代码引发运行恐慌时，只有其中所有的延迟函数都执行完毕后，该运行时恐慌才会真正被扩展至调用函数。

6. 高阶函数

6.1 函数的本质

在Go语言中，函数也是一种数据类型。

package main

import "fmt"

func main() {
    /*
    Go语言的数据类型：

        数值类型：整数，浮点
            进行运算操作，加减乘除，打印
        字符串：
            可以获取单个字符，截取子串，遍历，strings包下的函数操作。。
        数组，切片，map。。
            存储数据，修改数据，获取数据，遍历数据。。。
        函数：
            加(),进行调用

        注意点：
            函数作为一种复合数据类型，可以看做是一种特殊的变量。
                函数名()：将函数进行调用，函数中的代码会全部执行，然后将return的结果返回给调用处
                函数名：指向函数体的内存地址

     */
     //1.整型
     a := 10
     //运算：
     a += 5
     fmt.Println("a:",a)
     //2.数组，切片，map。。容器
     b := [4]int{1,2,3,4}
     b[0] =100
     for i:=0;i 空

     //var d  string
     //d = "hello"
     c = fun1 //将fun1的值(函数体的地址)赋值给c
     fmt.Println(c)

     fun1(10,20)
     c(100,200) //c也是函数类型的，加小括号也可以被调用

     res1 := fun2 //将fun2的值(函数的地址)赋值给res1，res1和fun2指向同一个函数体
     res2 := fun2(1,2) //将fun2函数进行调用，将函数的执行结果赋值给res2，相当于：a+b
     fmt.Println(res1)
     fmt.Println(res2)

     fmt.Println(res1(10,20))//也可以被调用
     //res2() //cannot call non-function res2 (type int)
}
func fun2(a,b int)int{
    return a + b
}
func fun1(a, b int){
    fmt.Printf("a:%d,b:%d\n",a,b)
}

6.2 匿名函数

匿名函数：没有名字的函数。

定义一个匿名函数，直接进行调用。通常只能使用一次。也可以使用匿名函数赋值给某个函数变量，那么就可以调用多次了。

package main

import "fmt"

func main() {
    /*
    匿名：没有名字
        匿名函数：没有名字的函数。

    定义一个匿名函数，直接进行调用。通常只能使用一次。也可以使用匿名函数赋值给某个函数变量，那么就可以调用多次了。

    匿名函数：
        Go语言是支持函数式编程：
        1.将匿名函数作为另一个函数的参数，回调函数
        2.将匿名函数作为另一个函数的返回值，可以形成闭包结构。
     */
     fun1()
     fun1()
     fun2 := fun1
     fun2()

     //匿名函数
     func (){
        fmt.Println("我是一个匿名函数。。")
     }()

     fun3:=func(){
        fmt.Println("我也是一个匿名函数。。")
     }
     fun3()
     fun3()

     //定义带参数的匿名函数
     func (a,b int){
        fmt.Println(a,b)
     }(1,2)

     //定义带返回值的匿名函数
     res1 := func (a, b int)int{
        return a + b
     }(10,20) //匿名函数调用了，将执行结果给res1
     fmt.Println(res1)

     res2 := func (a,b int)int{
        return a + b
     } //将匿名函数的值，赋值给res2
     fmt.Println(res2)

     fmt.Println(res2(100,200))
}

func fun1(){
    fmt.Println("我是fun1()函数。。")
}

匿名函数： Go语言是支持函数式编程：

将匿名函数作为另一个函数的参数，回调函数
将匿名函数作为另一个函数的返回值，可以形成闭包结构。

6.3 回调函数

回调函数：callback，就是将一个函数fun2作为函数fun1的一个参数。那么fun2叫做回调函数，fun1叫做高阶函数。

package main

import "fmt"

func main() {
    /*
    高阶函数：
        根据go语言的数据类型的特点，可以将一个函数作为另一个函数的参数。

    fun1(),fun2()
    将fun1函数作为了fun2这个函数的参数。

            fun2函数：就叫高阶函数
                接收了一个函数作为参数的函数，高阶函数

            fun1函数：回调函数
                作为另一个函数的参数的函数，叫做回调函数。
     */
    //设计一个函数，用于求两个整数的加减乘除运算
    fmt.Printf("%T\n", add)  //func(int, int) int
    fmt.Printf("%T\n", oper) //func(int, int, func(int, int) int) int

    res1 := add(1, 2)
    fmt.Println(res1)

    res2 := oper(10, 20, add)
    fmt.Println(res2)

    res3 := oper(5,2,sub)
    fmt.Println(res3)

    fun1:=func(a,b int)int{
        return a * b
    }

    res4:=oper(10,4,fun1)
    fmt.Println(res4)

    res5 := oper(100,8,func(a,b int)int{
        if b == 0{
            fmt.Println("除数不能为零")
            return 0
        }
        return a / b
    })
    fmt.Println(res5)

}
func oper(a, b int, fun func(int, int) int) int {
    fmt.Println(a, b, fun) //打印3个参数
    res := fun(a, b)
    return res
}

//加法运算
func add(a, b int) int {
    return a + b
}

//减法
func sub(a, b int) int {
    return a - b
}

6.4 闭包

闭包(closure)：

一个外层函数中，有内层函数，该内层函数中，会操作外层函数的局部变量(外层函数中的参数，或者外层函数中直接定义的变量)，并且该外层函数的返回值就是这个内层函数。

这个内层函数和外层函数的局部变量，统称为闭包结构。

package main

import "fmt"

func main() {
    /*
    go语言支持函数式编程：
        支持将一个函数作为另一个函数的参数，
        也支持将一个函数作为另一个函数的返回值。

    闭包(closure)：
        一个外层函数中，有内层函数，该内层函数中，会操作外层函数的局部变量(外层函数中的参数，或者外层函数中直接定义的变量)，并且该外层函数的返回值就是这个内层函数。

        这个内层函数和外层函数的局部变量，统称为闭包结构。

        局部变量的生命周期会发生改变，正常的局部变量随着函数调用而创建，随着函数的结束而销毁。
        但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁，因为内层函数还要继续使用。

     */
     res1 := increment() //res1 = fun
     fmt.Printf("%T\n",res1) //func() int
     fmt.Println(res1)
     v1 := res1()
     fmt.Println(v1) //1
     v2 := res1()
     fmt.Println(v2) //2
     fmt.Println(res1())
     fmt.Println(res1())
     fmt.Println(res1())
     fmt.Println(res1())

     res2 := increment()
     fmt.Println(res2)
     v3 :=res2()
     fmt.Println(v3) //1
     fmt.Println(res2())

     fmt.Println(res1())
}

func increment()func()int{ //外层函数
    //1.定义了一个局部变量
    i := 0
    //2.定义了一个匿名函数，给变量自增并返回
    fun := func ()int{ //内层函数
        i++
        return i
    }
    //3.返回该匿名函数
    return fun
}

闭包结构的注意点：
局部变量的生命周期会发生改变，正常的局部变量随着函数调用而创建，随着函数的结束而销毁。但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁，因为内层函数还要继续使用。

【Golang】Go基础之函数 | 四

1. 函数

1.1 什么是函数

1.2 函数的声明

1.3 函数的使用

2. 函数的参数

2.1 参数的使用

2.2 可变参

2.3 参数传递

3. 函数的返回值

3.1 什么是函数的返回值

3.2 一个函数可以返回多个值

3.3 空白标识符

4. 函数中变量的作用域

4.1 局部变量

4.2 全局变量

5. defer

5.1 延迟是什么?

5.2 延迟函数

5.3 延迟方法

5.4 延迟参数

5.5 堆栈的推迟

5.6 defer注意点

6. 高阶函数

6.1 函数的本质

6.2 匿名函数

6.3 回调函数

6.4 闭包