第三章、go语言函数，04_函数的使用1

无参、有参，无返回值、有返回值函数的定义和使用，不定参数函数，递归，回调函数

源代码

package main

import "fmt"

func main() {
	Myfunc0()
	Myfunc1(1001, 1002) //1001为实参
	Myfunc2(1003, 1004, 1005)
	Myfunc3()
	Myfunc3(1, 2, 3)
	test(1, 2, 3, 4) //调用Myfunc4

	h := Myfunc5()
	fmt.Println("h = ", h)
	i := Myfunc6()
	fmt.Println("i = ", i)

	j, k, l := Myfunc7()
	fmt.Printf("j = %d,k = %d,l = %d\n", j, k, l)

	max, min := Myfunc8(10, 20)
	fmt.Printf("max = %d,min = %d\n", max, min)
	//通过匿名变量丢弃某个返回值
	max2, _ := Myfunc8(10, 20)
	fmt.Printf("max2 = %d\n", max2)

	Myfunc9(3)
	m := Myfunc10(100)
	fmt.Printf("m = %d\n", m)

	var fTest FuncType    //声明一个函数类型FuncType的变量，起名为fTest
	fTest = Add           //是变量就可以赋值
	result := fTest(1, 2) //等价于Add(1, 2)
	fmt.Println("result = ", result)
	fTest = minus
	result = fTest(10, 5) //minus(10, 5)
	fmt.Println("result = ", result)

	ret := Calc(3, 5, Add)
	fmt.Printf("ret = %d\n", ret)
}

//1、无参无返回值函数
func Myfunc0() {
	a := 666
	fmt.Println("a = ", a)
}

//2、有参无返回值函数，b为形参
func Myfunc1(b int, c int) {
	fmt.Printf("b = %d,c = %d\n", b, c)
}
func Myfunc2(e, f, g int) { //相同类型的参数，可以只写一个类型符
	fmt.Printf("e = %d,f = %d,g = %d\n", e, f, g)
}

//3、不定参数类型
//...type不定参数类型
//不定参数，一定只能放在形参中的最后一个参数
func Myfunc3(args ...int) { //传递的参数可以是0个或多个
	fmt.Println("len(args) = ", len(args))
	for i := 0; i < len(args); i++ {
		fmt.Printf("args[%d] = %d\n", i, args[i])
	}
	for i, data := range args {
		fmt.Printf("args[%d] = %d\n", i, data)
	}
}

//4、不定参数的传递
func Myfunc4(tmp ...int) {
	for _, data := range tmp {
		fmt.Println("data = ", data)
	}
}
func test(args ...int) {
	Myfunc4(args...)     //全部参数都传递给Myfunc4
	Myfunc4(args[2:]...) //把下标[2~ ]的参数传递给Myfunc4
	Myfunc4(args[:2]...) //把下标[0~2)的参数传递给Myfunc4
}

//5、无参有一个返回值的函数
func Myfunc5() int {
	return 2001
}

//给返回值起一个变量名，go推荐，常用写法
func Myfunc6() (ret int) {
	ret = 2002
	return
}

//6、无参有多个返回值
func Myfunc7() (a int, b int, c int) {
	a, b, c = 3001, 3002, 3003
	return
}

//7、有参有返回值函数
func Myfunc8(a, b int) (max, min int) {
	if a > b {
		max = a
		min = b
	} else {
		max = b
		min = a
	}
	return
}

//8、递归函数的调用
func Myfunc9(a int) {
	if a == 1 {
		fmt.Println("a = ", a)
		return
	}
	Myfunc9(a - 1)
	fmt.Println("a = ", a)
}

//递归实现累加，a=100，返回100+99+98+97...+2+1
func Myfunc10(a int) int {
	if a == 1 {
		return 1
	}
	return a + Myfunc10(a-1)
}

//9、函数类型
func Add(a, b int) int {
	return a + b
}
func minus(a, b int) int {
	return a - b
}

//函数也是一种数据类型，通过type给一个函数类型起名
//FuncType是一个函数类型
type FuncType func(int, int) int

//10、回调函数
//函数有一个参数是函数类型，这个函数就是回调函数
//回调函数作用：实现多态(调用同一个接口，实现不同的功能)
func Calc(a, b int, fTest FuncType) (result int) {
	fmt.Println("Calc:")
	result = fTest(a, b)
	return
}

打印输出

a =  666
b = 1001,c = 1002
e = 1003,f = 1004,g = 1005
len(args) =  0
len(args) =  3
args[0] = 1
args[1] = 2
args[2] = 3
args[0] = 1
args[1] = 2
args[2] = 3
data =  1
data =  2
data =  3
data =  4
data =  3
data =  4
data =  1
data =  2
h =  2001
i =  2002
j = 3001,k = 3002,l = 3003
max = 20,min = 10
max2 = 20
a =  1
a =  2
a =  3
m = 5050
result =  3
result =  5
Calc:
ret = 8