Go学习:函数

单个返回值

func main() {
	fmt.Println(eval(2,3,"*"))
}
func eval(a int, b int, op string) int {
	switch op {
	case "+":
		return a + b
	case "-":
		return a - b
	case "*":
		return a * b
	case "/":
		return a/b
	default:
		panic("unsupported operation:" + op)
	}
}
// 执行输出6

两个返回值

不定义返回值的属性名

func main() {
	fmt.Println(div(10, 3))
}
func div(a, b int) (int, int) {
	return a / b, a % b
}
// 求商和余数;输出3和1

定义返回值的属性名

func main() {
	q, r := div(10, 3)
	fmt.Println(q, r)
}
func div(a, b int) (q,r int) {
	q = a / b
	r = a % b
	return
}

一般go函数定义两个返回值都是返回一个值和一个error;定义返回值属性名是为了调用的时候可以自动的使用函数的返回值,但是这种返回值只有在函数代码比较少的时候才适用;代码太多不好看到在哪里给返回值进行赋值了;

返回一个数值一个错误

• 第一段代码如果我们op不传加减乘除符号就会报错,中断程序的执行;把eval函数改成两个返回值,一个int一个error,程序就不会在因为报错中断执行了,如果发生错误就会将error返回;

func main() {
	if res, err := eval(4, 4, "/");err != nil{
		fmt.Println("Error:",err)
	}else {
		fmt.Println(res)
	}
	if res, err := eval(3, 4, "--");err != nil{
		fmt.Println("Error:",err)
	}else {
		fmt.Println(res)
	}
}
func eval(a int, b int, op string) (int, error) {
	switch op {
	case "+":
		return a + b, nil
	case "-":
		return a - b, nil
	case "*":
		return a * b, nil
	case "/":
		return a / b, nil
	default:
		//panic("unsupported operation:" + op)
		return 0, fmt.Errorf("unsupported operation: %s", op)
	}
}
// 一个返回正确数值;一个返回错误
// 1
// Error: unsupported operation: --

两个返回值只使用一个

func main() {
	if res, err := eval(4, 4, "/");err != nil{
		fmt.Println("Error:",err)
	}else {
		fmt.Println(res)
	}
	if res, err := eval(3, 4, "--");err != nil{
		fmt.Println("Error:",err)
	}else {
		fmt.Println(res)
	}
}
func eval(a int, b int, op string) (int, error) {
	switch op {
	case "+":
		return a + b, nil
	case "-":
		return a - b, nil
	case "*":
		return a * b, nil
	case "/":
		q, _ := div(a, b)
		return q, nil
	default:
		//panic("unsupported operation:" + op)
		return 0, fmt.Errorf("unsupported operation: %s", op)
	}
}

func div(a, b int) (q,r int) {
	q = a / b
	r = a % b
	return
}
// 在使用除法的时候,我们只使用一个商就够了,不需要用余数,但是这样编辑器会报错的;
// 使用_表示不用的返回值,编辑器就不会报错了
// 一个返回正确数值;一个返回错误
// 1
// Error: unsupported operation: --

函数作为参数

func main() {
	fmt.Print(apply(pow,3,2))
}
func apply(op func(int, int) int, a, b int) int {
	// 通过反射拿到函数指针
	pointer := reflect.ValueOf(op).Pointer()
	// 获取函数名
	opName := runtime.FuncForPC(pointer).Name()
	fmt.Printf("Calling function %s with args (%d,%d) \n",opName,a,b)
	return op(a,b)
}

func pow(a, b int) int {
	return int(math.Pow(float64(a),float64(b)));
}
// 打印函数信息以及求3的平方
// Calling function main.pow with args (3,2) 
// 9

匿名函数

• 不再新建pow函数,直接在传参的时候写一个匿名函数

func main() {
	fmt.Print(apply(func(a int, b int) int {
		return int(math.Pow(float64(a), float64(b)))
	}, 3, 2))
}
func apply(op func(int, int) int, a, b int) int {
	// 通过反射拿到函数指针
	pointer := reflect.ValueOf(op).Pointer()
	// 获取函数名
	opName := runtime.FuncForPC(pointer).Name()
	fmt.Printf("Calling function %s with args (%d,%d) \n",opName,a,b)
	return op(a,b)
}
// 打印函数信息以及求3的平方;因为这个函数是匿名函数所以打印出来的函数名是func1
// Calling function main.main.func1 with args (3,2) 
// 9

可变参数

func main() {
	fmt.Println(sum(1,2,3,4))
}
func sum(numbes ...int) int {
	res := 0
	for i := range numbes{
		res += numbes[i]
	}
	return res
}
// 传入1,2,3,4求和
// 10

总结

1. 返回值类型写在最后面
2. 函数返回多个值的时候可以对返回值起名字,仅用于非常简单的函数,对调用者而言没有区别,仅有一个提示的作用
3. go语言的函数可以返回多个值(通常是一个返回值,一个error)
4. 函数可以作为参数
5. go语言有匿名函数,但是不像java那样有Lambda表达式
6. 没有默认参数,可选参数;但是有可变参数