Go_函数

1.函数

1.1 函数定义

func functionName([paramenter list]) [returnTypes]{
	//body
}

• func 函数声明的关键字
• functionName 函数名称
• paramenter list 函数参数，非必须
• returnTypes 函数返回参数，非必须

func GetSum(num1 int, num2 int)int{
//也可以这样定义 函数参数相同类型可以省略掉前面的类型声明
//func GetSum(num1, num2 int)int{
	result := num1 + num2
	return result
}

1.2值传递与引用传递

在go语言中分为值传递和引用传递
如果想要函数直接修改参数的值，需要传递指针，将变量的地址作为参数传递到函数中。

func paramFunc(a int, b *int ,c []int){
	a = 100
	*b = 100
	c[1] = 100
	fmt.Println(a)
	fmt.Println(*b)
	fmt.Println(c)
}

func main() {
	a := 1
	b := 1
	c := []int{1, 2, 3}
	paramFunc(a, &b, c)

	fmt.Println("main:")
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
}

//输出结果
paramFunc:
100
100
[1 100 3]
main:
1
100
[1 100 3]

1.3 变长参数

在go语言中也支持变长参数，但需要注意的是变长参数必须放在函数参数的最后一个，否则会报错

func main(){
       slice:=[]int{7,9,3,5,1}
       x:=min(slice...)
       fmt.Printf("The minimum is:%d",x)
}

func min(s ...int) int {
	if len(s) == 0{
		return
	}
	min := s[0]
	for _, v:=range s{
		if v<min {
			min = v
		}
	}
	return min
}

1.4 多返回值

func div(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("The divisor cannot be zero.")
	}
	return a / b, nil
}

func main() {
	result, err := div(1, 2)
	if err != nil {
		fmt.Printf("error: %v", err)
		return
	}
	fmt.Println("result: ", result)
}

1.5 匿名函数

func main() {
	f := func() string {
		return "hello world"
	}
	fmt.Println(f())
}

1.6 闭包函数

闭包就是一个函数和一个函数外的变量的封装，而且这个变量就对应着类中的静态变量

func add() func(int) int {
	//n str  属于两个函数外变量
	n := 10
	str := "string"
	
	return func(x int) int {
		n = n + x
		str += strconv.Itoa(x)
		fmt.Print(str, " ")
		return n
	}
}

func main() {
	f := add()
	fmt.Println(f(1))
	fmt.Println(f(2))

	f = add()
	fmt.Println(f(1))
	fmt.Println(f(2))

}

//输出结果
string1 11
string12 13
string1 11
string12 13