【Golang】快速复习指南QuickReview（四）——函数

函数

作为增强代码的复用性性和可读性，函数必不可少。

1.C#中的函数

1.1 可变参数params

static int IntSum(int x, int y)
{
    return x + y;
}

//重载，可变参数
static int IntSum(params int[] x)
{
    int sum = 0;
    for (int i = 0; i < x.Length; i++)
    {
        sum += x[i];
    }
    return sum;
}

1.2 返回多个值

参数out

static void Calc(int x, int y, out int sum, out int sub)
{
    sum = x + y;
    sub = x - y;
}

Tuple-元组

//元组
// static (int, int) Calc(int x, int y)
static (int sum, int sub) Calc(int x, int y)
{
    return (x + y, x - y);
}

1.3 delegate委托(函数类型)

C#中函数类型就是委托

public delegate (int, int) CalculationHandler(int x, int y);

//使用
static void TestDelegate(CalculationHandler handler)
{

}

//调用传值
TestDelegate((x, y) =>
             {
                 return (x + y, x - y);
             });
//匿名函数
TestDelegate(delegate (int x, int y)
             {
                 return (x + y, x - y);
             });

2.Golang中的函数

Golang的返回值在函数名及参数之后，函数必须写注释，且以函数名开头，否则golint会有绿色的提示

2.1 可变参数...

// IntSum 写注释哟
func IntSum(x int, y int) int {
    return x + y
}

//go是不支持函数重载的
func Sum(x ...int) int {
	//此时x是一个切片
	sum := 0
	for _, v := range x {
		sum = sum + v
	}
	return sum
}

2.2 返回多个值

多看几个形式，不为别的，只为能看懂别人的源码

func Calc(x int, y int) (sum int,sub int) {
	sum = x + y
	sub = x - y
	return sum, sub
}

func Calc(x int, y int) ( int, int) {
    sum := x + y
    sub := x - y
	return sum, sub
}

func Calc(x, y int) (int, int) {
	sum := x + y
	sub := x - y
	return sum, sub
}

2.3 函数类型

函数做为一种类型，Golang的定义更直接：

type calculation func(int, int) (int, int)

2.3.1 使用

func main() {
    var calc calculation
    calc = addOrSub
    sum, sub := calc(5, 6)
	fmt.Printf("result:sum-%v sub-%v 
", sum, sub)
    sum1, sub2 := testFuncType(8, 6, addOrSub)
    fmt.Printf("result:sum-%v sub-%v 
", sum1, sub2)
}
type calculation func(int, int) (int, int)
func addOrSub(x, y int) (int, int) {
	return x + y, x - y
}

// testFuncType 这个就比较像委托了
func testFuncType(x, y int, op calculation) (int, int) {
	return op(x, y)
}

2.3.2 匿名函数

Golang的匿名函数没有任何关键字，也是简单粗暴的使用：

addOrSubTest := func(x, y int) (int, int) {
    return x + y, x - y
}
sum3, sub3 := addOrSubTest(9, 6)
fmt.Printf("anonymous function:sum-%v sub-%v 
", sum3, sub3)

2.4 返回值为函数

既然函数是一种类型，那么也可作为函数的返回值

func do(s string) func(int, int) int {
	switch s {
	case "+":
		return func(x int, y int) int {
			return x + y
		}
	case "-":
		return func(x int, y int) int {
			return x - y
		}
	default:
		return nil
	}
}

2.5 新内容 defer

defer语句会将其后面跟随的语句进行延迟处理。函数即将return,将延迟处理的语句按defer定义的逆序进行执行，也就是说，先定义defer的语句最后被执行，最后定义的defer的语句，最先执行。像栈一样，先进后出，后进先出。

func main() {
    var calc calculation
    calc = addOrSub
    sum, sub := calc(5, 6)
	fmt.Printf("result:sum-%v sub-%v 
", sum, sub)
}
type calculation func(int, int) (int, int)
func addOrSub(x, y int) (int, int) {
	defer fmt.Println("addOrSub1")
	defer fmt.Println("addOrSub2")
	defer fmt.Println("addOrSub3")
	fmt.Printf("result:%v and %v
", x+y, x-y)
	return x + y, x - y
}

result:11 and -1
addOrSub3
addOrSub2
addOrSub1
result:sum-11 sub--1

更复杂(坑爹)的defer示例，请参阅一些面试题。

再次强调：这个系列并不是教程，如果想系统的学习，博主可推荐学习资源。