Go 语言函数

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

函数定义

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

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

例如：

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
}
---------------------------------------------
最大值是： 200

函数参数
函数传递值
传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
默认情况下，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*/
   fmt.Printf("swap 函数值 %d\n", temp)
   return temp;
}

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

package main 

import "fmt"

func main(){
	var a int = 100
	var b int = 200

	fmt.Printf("原 a %d", a)
	fmt.Printf("原 b %d", b)

	swap(&a, &b)

	fmt.Printf("修改后, a %d", a)
	fmt.Printf("修改后, b %d", b)
}



func swap(x *int, y *int){
	var temp int
	temp = *x
	*x = *y
	*y = temp
}
-----------------------------
原 a 100 原 b 200   修改后, a 200   修改后, b 100

Go 语言函数作为值
Go 语言可以很灵活的创建函数，并作为值使用。

package main 

import (
	"fmt"
	"math"
)


func main(){
	getSquareRoot := func(x float64) float64{
		return math.Sqrt(x)
	}

	fmt.Println(getSquareRoot(10))
}
-------------------------------------------------------------
3.1622776601683795

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

package main 

import "fmt"


func getSequence() func() int {
	i := 0
	return func() int {
		i += 1
		return i
	}
}


func main(){
	nextNumber := getSequence()

	fmt.Println(nextNumber())
	fmt.Println(nextNumber())
	fmt.Println(nextNumber())

	nextNumber1 := getSequence()  
    fmt.Println(nextNumber1())
    fmt.Println(nextNumber1())
    fmt.Println(nextNumber1())
}
--------------------------------------
1
2
3
1
2
3

Go 语言函数方法
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("圆的面积 = ", c1.getArea())
}


func (c Circle) getArea() float64 {
	return 3.14 * c.radius * c.radius
}
-----------------------------------------------------
圆的面积 =  314

猜你喜欢