[go系列] 函数

函数 & 异常

go里的函数支持 ：函数 匿名 闭包

一、函数语法

func 函数名(参数)返回值{
函数体内容
}
//例子
func Add(a,b int) int{
return a+b
}

1. 函数名：由字母、数字、下划线组成。但函数名的第一个字母不能是数字。在同一个包 内，函数名也称不能重名（包的概念详见后文）。

2. 参数：参数由参数变量和参数变量的类型组成，多个参数之间使用,分隔。

3. 返回值：返回值由返回值变量和其变量类型组成，也可以只写返回值的类型，多个返回 值必须用()包裹，并用,分隔。

4. 函数体：实现指定功能的代码块

参数

1. 正常参数
2. 简化常数
3. 可变参数

func demo1(a int,b int) int{return a+b}
func demo2(a,b int)int{return a+b}
func demo3(x int,y ... int)int{
	fmt.Println(x, y) 
	sum := x 
	for _, v := range y { 
	sum = sum + v 
	} 
	return sum
}

ret6 := demo1(100, 10) 
ret7 := demo2(100, 10) 
ret8 := demo3(100, 10, 20, 30)
fmt.Println(ret6, ret7, ret8) //100 110 160

返回值

func demo1(a,b int) (int,int){
	add:=a+b
	sub=a-b
	return add,sub
}
func demo1(a,b int) (x,y int){
	add:=a+b
	sub=a-b
	return 
}

二、函数类型(C# 委托)

go中的函数类型，把函数当做一种类型，赋值，传参，执行，就跟C#中的委托一样

//语法
type 定义类型名 func(a,b int)int
//例子
//1.定义
type myfunc func(a, b int) int

func main() {
	var c myfunc //2.声明
	c = Add //3.赋值
	fmt.Printf("%v %T
", c, c)
	fmt.Println(c(3, 3)) //4.使用执行

	f := c
	fmt.Println(f(1, 2))
    
    fmt.Println(ParameterDelegate(5, 5, f))
    
    fmt.Println(ReturnDelegate("+")(10, 20))
}


// Add 添加方法
func Add(a, b int) int {
	return a + b
}

// Sub 减方法
func Sub(a, b int) int {
	return a - b
}

// ParameterDelegate 把委值当做参数
func ParameterDelegate(a, b int, op func(int, int) int) int {
	return op(a, b)
}
// ReturnDelegate 返回函数类型
func ReturnDelegate(a string) func(int, int) int {
	switch a {
	case "+":
		return Add
	case "-":
		return Sub
	default:
		return nil
	}
}

三、 闭包 匿名

闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部 连接起来的桥梁。或者说是函数和其引用环境的组合体

func adder() func(int) int { 
var x int 
return func(y int) int { 
    x += y 
    return x 
    } 
} 
func main() { 
    var f = adder() 
    fmt.Println(f(10)) //10 
    fmt.Println(f(20)) //30 
    fmt.Println(f(30)) //60
    f1 := adder() 
    fmt.Println(f1(40)) //40 
    fmt.Println(f1(50)) //90
}

匿名函数就比较简单 ，就不是取名

func main(){
	var ni=func(a,b int)in{
	return a+b
	}
   fmt.Println(	ni(1,2))
    
 	//以及所谓的自执行函数
 	func(a,b int) int{
 	 fmt.Println(a+b)
 	}(10,5)
}

四、defer 异常

defer 主要就是延迟执行，并采用 Stack（栈） 的概念，先进后出

//例子
func main() {
    fmt.Println("start") 
    defer fmt.Println(1) 
    defer fmt.Println(2) 
    defer fmt.Println(3) 
    fmt.Println("end") 
}
输出结果：
start 
end 
3 
2 
1

由于 defer 语句延迟调用的特性，所以 defer 语句能非常方便的处理资源释放问题。

比如： 资源清理、文件关闭、解锁及记录时间等

//异常处理

附函数