10.Go_Function(函数)

Go函数

Go 语言最少有个 main() 函数。
函数声明告诉了编译器函数的名称，返回类型，和参数。
Go 语言标准库提供了多种可动用的内置的函数。

Go 语言函数定义格式:
//func:函数由 func 开始声明
//function_name：函数名称
//parameter list：参数列表
//return_types：返回类型，函数返回一列值。
//函数体：函数定义的代码集合。
func function_name( [parameter list] ) [return_types] {
   函数体
}

例如:
//传入两个整型参数 num1 和 num2，并返回这两个参数的最大值
func max(num1,num2 int) int  {

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

函数调用

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

例如:
package main
import "fmt"
func main() {
    var a int = 100
    var b int = 60
    var res int
    res = max(a,b)
    fmt.Printf("最大值:%d",res)
}
//传入两个整型参数 num1 和 num2，并返回这两个参数的最大值
func max(num1,num2 int) int  {
    var  result int
    if (num1 > num2){
        result = num1
    }else {
        result = num2
    }
    return  result
}

运行结果
最大值:100

函数返回多个值

package main
import "fmt"
func main() {
    a,b := swap("hello","world")
    fmt.Println(a,b)
}
//交换
func swap(x,y string) (string,string){
    return  y,x
}

运行结果:
world hello

函数值传递

func swap(x,y int) int  {
    var temp int
    temp = x
    x = y
    y = temp
    return  temp
}

函数引用传递

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

func swap(x *int ,y *int) {
   var temp int 
   temp = *x //保存x地址上的值
   *x = *y  //将y值赋给x
   *y = temp //将temp值赋给y
}

例如:
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)
    swap1(&a,&b)
    fmt.Printf("a=%d\n",a)
    fmt.Printf("b=%d\n",b)
}
func swap1(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 语言可以很灵活的创建函数，并作为值使用。

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

运行结果:
6

函数闭包

Go 语言支持匿名函数，可作为闭包。

例如:
package main
import "fmt"
func main() {
    //nextNumber 为一个函数,函数i为0
    nextNumber := getSequence()
    //调用nextNumber函数,变量自增1并返回
    fmt.Println(nextNumber())
    fmt.Println(nextNumber())
    fmt.Println(nextNumber())
    //创建新的函数nextNumber1
    nextNumber1 := getSequence()
    fmt.Println(nextNumber1())
    fmt.Println(nextNumber1())
}
func getSequence() func() int{
    i := 0
    return  func() int{
        i += 1
        return  i
    }
}

运行结果:
1
2
3
1
2

函数方法

Go 语言中同时有函数和方法。

语法格式
func (variable_name variable_data_type) function_name() [return_type]{
   /* 函数体*/
}

例如:
package main
import (
    "fmt"
)
//定义函数
type Cirecle struct {
    radius float64
}
func main() {
    var c1 Cirecle
    c1.radius = 10.00
    fmt.Println("面积=",c1.getArea())
}
func (c Cirecle) getArea() float64  {
    //c.radius-->>Circle类型对象中的属性
    return  3.14 * c.radius * c.radius
}

运行结果:
面积= 314