Go 语言函数

函数定义与调用

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

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 }

　　

函数返回多个值

?

1 2 3 4 5 6 7 8 9 10 11 12

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 语言函数值传递值

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

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 }

　　

Go 语言函数引用传递值

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

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 */ }

　　

Go 语言函数作为值

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

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

　　

Go 语言函数闭包

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

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

　　

Go 语言函数方法

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

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 }

　　

defer语句

Go语言中的defer语句会将其后面跟随的语句进行延迟处理

?

1 2 3 4 5 6 7 8 9 10 11

package main   import "fmt"   func main() {     fmt.Println("开始")     defer fmt.Println(1)     defer fmt.Println(2)     defer fmt.Println(3)     fmt.Println("结束") }