函数 - Go 语言学习笔记-白红宇

函数是什么？

函数是一块执行特定任务的代码，是构成代码执行的逻辑结构。

在Go语言中，函数的基本组成是：关键字func、函数名、参数列表、返回值列表、函数体和返回语句。

函数的声明

Go语言函数声明语法如下：

func function_name( [parameter list] ) [return_types] {    函数体（具体实现的功能）}复制代码

函数语法解析：

func：函数由 func 开始声明

function_name：函数名称，函数名和参数列表一起构成了函数签名

parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。

return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。

函数体：函数定义的代码集合。

实例：

func calculateBill(price int, no int) int {      var totalPrice = price * no     // 商品总价 = 商品单价 * 数量    return totalPrice               // 返回总价}/* 上述函数有两个整型的输入 price 和 no，返回值 totalPrice 为 price 和 no 的乘积，也是整数类型。*/复制代码

如果有连续若干个参数，它们的类型一致，那么我们无须一一罗列，只需在最后一个参数后添加该类型。例如:

func calculateBill(price, no int) int {    var totalPrice = price * no    return totalPrice}复制代码

函数调用

当创建函数时，你定义了函数需要做什么，通过调用该函数来执行指定任务。

调用函数，向函数传递参数，并返回值，例如：

package mainfunc calculateBill(price, no int) int {    var totalPrice = price * no    return totalPrice}func main() {    var ret int    ret = calculateBill(10, 5)}复制代码

函数参数

函数使用的参数称为函数的形参，形参就像定义在函数体内的局部变量。调用函数，可以通过两种方式来传递参数：

1. 值传递

值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。例如：```package mainimport "fmt"func main() {    /* 定义局部变量 */    var a int = 100    var b int = 200        fmt.Printf("交换前 a 的值为 : %d\n", a )    fmt.Printf("交换前 b 的值为 : %d\n", b )        /* 通过调用函数来交换值 */    swap(a, b)        fmt.Printf("交换后 a 的值 : %d\n", a )    fmt.Printf("交换后 b 的值 : %d\n", b )}func swap(x, y int) int {    var temp int        temp = x    // 保存 x 的值    x = y       // 将 y 值赋给 x    y = temp    // 将 temp 值赋给 y        return temp;}```以下代码执行结果为：交换前 a 的值为 : 100
交换前 b 的值为 : 200
交换后 a 的值 : 100
交换后 b 的值 : 200复制代码

2. 引用传递

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。引用传递指针参数传递到函数内，例如：```package mainimport "fmt"func main() {    /* 定义局部变量 */    var a int = 100    var b int= 200    fmt.Printf("交换前，a 的值 : %d\n", a )    fmt.Printf("交换前，b 的值 : %d\n", b )    /* 调用 swap() 函数    * &a 指向 a 指针，a 变量的地址    * &b 指向 b 指针，b 变量的地址    */    swap(&a, &b)    fmt.Printf("交换后，a 的值 : %d\n", a )    fmt.Printf("交换后，b 的值 : %d\n", b )}func swap(x *int, y *int) {    var temp int    temp = *x       // 保存 x 地址上的值    *x = *y         // 将 y 值赋给 x    *y = temp       // 将 temp 值赋给 y}```以上代码执行结果为：交换前，a 的值 : 100
交换前，b 的值 : 200
交换后，a 的值 : 200
交换后，b 的值 : 100复制代码

多返回值

Go语言支持一个函数可以有多个返回值，如果一个函数有多个返回值，那么这些返回值必须用 ( 和 ) 括起来。例如，定义个以矩形的长和宽为输入参数，计算并返回矩形面积和周长的函数 rectProps。

面积 = 长 * 宽

周长 = 2 * ( 长 + 宽 )

package mainimport (      "fmt")func rectProps(length, width float64)(float64, float64) {      var area = length * width    var perimeter = (length + width) * 2    return area, perimeter}func main() {      area, perimeter := rectProps(10.8, 5.6)    fmt.Printf("Area: %f Perimeter: %f", area, perimeter) }复制代码

以上实例执行结果为：Area: 60.480000 Perimeter: 32.800000

命名返回值

从函数中可以返回一个命名值。一旦命名了返回值，可以认为这些值在函数第一行就被声明为变量了。

例如：

func rectProps(length, width float64)(area, perimeter float64) {      area = length * width    perimeter = (length + width) * 2    return // 不需要明确指定返回值，默认返回 area, perimeter 的值}复制代码

注意, 函数中的 return 语句没有显式返回任何值。由于 area 和 perimeter 在函数声明中指定为返回值, 因此当遇到 return 语句时, 它们将自动从函数返回。

空白符

_ 在 Go 中被用作空白符，可以用作表示任何类型的任何值。

函数rectProps计算的是面积和周长。假使我们只需要计算面积，而并不关心周长的计算结果，这时可以使用空白符 _ 替换周长。例如：

package mainimport (      "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) // 返回值周长被丢弃    fmt.Printf("Area %f ", area)}复制代码

在程序 area, _ := rectProps(10.8, 5.6) 的这一行，空白符 _ 用来跳过不要的计算结果。

函数用法

1. 函数作为另外一个函数的实参

函数定义后可作为另外一个函数的实参数传入例如：

package mainimport (    "fmt"    "math")func main(){    // 声明函数变量    getSquareRoot := func(x float64) float64 {        return math.Sqrt(x)    }        // 使用函数    fmt.Println(getSquareRoot(9))}复制代码

2. 闭包

闭包是匿名函数，可在动态编程中使用。

Go 语言支持匿名函数，可作为闭包。匿名函数是一个"内联"语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必声明。示例：

package mainimport "fmt"func getSequence() func() int {    i:=0    return func() int {        i+=1        return i      }}func main(){    /* nextNumber 为一个函数，函数 i 为 0 */    nextNumber := getSequence()          /* 调用 nextNumber 函数，i 变量自增 1 并返回 */    fmt.Println(nextNumber())    fmt.Println(nextNumber())    fmt.Println(nextNumber())        /* 创建新的函数 nextNumber1，并查看结果 */    nextNumber1 := getSequence()      fmt.Println(nextNumber1())    fmt.Println(nextNumber1())}复制代码

函数 getSequence() ，返回另外一个函数(匿名函数)，该函数的目的是在闭包中递增 i 变量。

3.方法

方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。语法格式如下：

func (variable_name variable_data_type) function_name() [return_type]{    /* 函数体*/}复制代码

下面定义一个结构体类型和该类型的一个方法：

package mainimport (    "fmt"  )/* 定义结构体 */type Circle struct {    radius float64}func main() {    var c1 Circle    c1.radius = 10.00    fmt.Println("圆的面积 = ", c1.getArea())}//该 method 属于 Circle 类型对象中的方法func (c Circle) getArea() float64 {    //c.radius 即为 Circle 类型对象中的属性    return 3.14 * c.radius * c.radius}复制代码

以上代码执行结果为：的面积 = 314