• 函数是基本的代码块,用于执行一个任务。
    Go 语言最少有个main()函数。
    你可以通过函数来划分不同功能,逻辑上每个函数执行的是指定的任务。
    函数声明告诉了编译器函数的名称,返回类型,和参数。
    Go 语言标准库提供了多种可动用的内置的函数。例如len()函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度,如果传入的是数字,则返回数组中包含的函数个数。

    函数定义

    Go 语言函数定义格式如下:

    func function_name( [parameter list] ) [return_types] {
       /* 函数体 */
    }
    

    函数定义解析:

    • func:函数由 func 开始声明
    • function_name:函数名称,函数名和参数列表一起构成了函数签名。
    • [parameter list]:参数列表,参数就像一个占位符,当函数被调用时,你可以将值传递给参数,这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的,也就是说函数也可以不包含参数。
    • return_types:返回类型,函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值,这种情况下 return_types 不是必须的。
    • 函数体:函数定义的代码集合。

    例子:
    下面为一个返回两数最大值的函数:

    /* 函数返回两个数的最大值 */
    func max(num1, num2 int) int {
       /* 声明局部变量 */
       result int
       if (num1 > num2) {
          result = num1
       } else {
          result = num2
       }
       return result
    }
    

    返回值

    Go语言函数可以返回多个值:

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

    函数参数

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

    传递类型描述
    值传递值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。
    引用传递引用传递是指在调用函数时将实际参数的地址传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。

    值传递

    值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。
    默认情况下,Go 语言使用的是值传递,即在调用过程中不会影响到实际参数。
    下面我们定义一个交换两个值的函数,并在mian()函数中调用它,然后在最后再返回这两个值

    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
    交换前 b 的值为 : 200
    交换后 a 的值 : 100
    交换后 b 的值 : 200
    

    我们看到,执行swap()函数后,两值并没有发生变换。

    引用传递

    引用传递是指在调用函数时将实际参数的地址传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。
    引用传递将指针参数传递到函数内,以下是交换函数 swap() 使用了引用传递:

    /* 定义交换值函数*/
    func swap(x *int, y *int) {
       var temp int
       temp = *x    /* 保持 x 地址上的值 */
       *x = *y      /* 将 y 值赋给 x */
       *y = temp    /* 将 temp 值赋给 y */
    }
    

    以下我们通过使用引用传递来调用 swap() 函数:

    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
    交换前,b 的值 : 200
    交换后,a 的值 : 200
    交换后,b 的值 : 100
    

    将函数作为值传递

    Go 语言可以很灵活的创建函数,并作为值使用。以下实例中我们在定义的函数中初始化一个变量,该函数仅仅是为了使用内置函数 math.sqrt() ,实例为:

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

    以上代码执行结果为:

    3
    

    函数方法

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

    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("Area of Circle(c1) = ", c1.getArea())
    }
    //该 method 属于 Circle 类型对象中的方法
    func (c Circle) getArea() float64 {
      //c.radius 即为 Circle 类型对象中的属性
      return 3.14 * c.radius * c.radius
    }
    

    以上代码执行结果为:

    Area of Circle(c1)  =  314
    

    参考