函数 - Go 语言学习笔记

play76207
211 阅读6分钟

函数是什么？

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

在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 main
func calculateBill(price, no int) int {
    var totalPrice = price * no
    return totalPrice
}

func main() {
    var ret int
    ret = calculateBill(10, 5)
}

函数参数

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

1. 值传递

值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

例如：
```
package main
import "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<br />
交换前 b 的值为 : 200<br />

交换后 a 的值 : 100<br />
交换后 b 的值 : 200

2. 引用传递

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

引用传递指针参数传递到函数内，例如：
```
package main
import "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<br />
交换前，b 的值 : 200<br />

交换后，a 的值 : 200<br />
交换后，b 的值 : 100

多返回值

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

  • 面积 = 长 * 宽
  • 周长 = 2 * ( 长 + 宽 )
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, 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 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) // 返回值周长被丢弃
    fmt.Printf("Area %f ", area)
}

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

函数用法

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

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

package main
import (
    "fmt"
    "math"
)

func main(){
    // 声明函数变量
    getSquareRoot := func(x float64) float64 {
        return math.Sqrt(x)
    }
    
    // 使用函数
    fmt.Println(getSquareRoot(9))
}

2. 闭包

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

package main
import "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 main
import (
    "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

avatar
文章
阅读
粉丝