go语言学习第三天==>函数、匿名函数与闭包、错误处理、defer关键字、painc()和recover()、type关键字

- go语言学习第三天==>函数、匿名函数与闭包、错误处理、defer关键字、painc()和recover()、type关键字

//
- 函数
func   函数名 (参数表)  (返回值表)/返回值  {函数体}
demo

func example1(x int) int {     
	if x == 0 {         
		return 5     
	} else{         
		return x     
	} 
}
//或者
func example2(x int) (int,int) {     
	if x == 0 {         
		return 1,2     
	} else{         
		return  2,2   
	} 
	return 2,22
}

函数调用
包名.函数名(参数表)
或者 同包可以不写
函数名(参数表)

example1(1)
//假设example2在包test中则
a,b:=test.example2(2)
//或者
test.example2(22222)

不定参数

func myfunc(args ...int) {     //接收不定数量的int类型参数
	for _, arg := range args {     
		fmt.Println(arg)     
	} 
}
//调用
myfunc()
myfunc(1)
myfunc(1,2)

不定参数传递

//假设有个myfunc2(args..int)
func myfunc(args ...int) { 

  // 按原样传递     
  myfunc3(args...) 
  // 传递片段，实际上任意的int slice都可以传进去     
  myfunc3(args[1:]...)   
} 

任意类型不定参数
用interface{}传递任意类型数据是Go语言的惯例用法。使用interface{}仍然是类型安全的

func Printf(format string, args ...interface{}) {  
	// ...  
} 

demo

package main 
 
import "fmt" 
 
func MyPrintf(args ...interface{}) {     
	for _, arg := range args {         
	switch arg.(type) {             
		case int:                   
			fmt.Println(arg, "is an int value.")             
		case string:                  
			fmt.Println(arg, "is a string value.")             
		case int64:                  
			fmt.Println(arg, "is an int64 value.")             
		default:                 
			fmt.Println(arg, "is an unknown type.")         
		}     
	} 
}
func main() {     
	var v1 int = 1     
	var v2 int64 = 234     
	var v3 string = "hello"     
	var v4 float32 = 1.234
	MyPrintf(v1, v2, v3,  v4) 
}

结果为：
1 is an int value.
234 is an int64 value.
hello is a string value.
1.234 is an unknown type.

多返回值

func (file *File) Read(b []byte) (n int, err Error)
//调用
n, _ := f.Read(buf)

//
匿名函数与闭包
1匿名函数 --即没有函数名

func(a, b int, z float64) bool {     
	return a*b <int(z)  
}

匿名函数可以直接赋值给一个变量

f := func(x, y int) int {     
	return x + y  
}

或者直接调用

func(a int) {     
		fmt.Println(a)
} (6666) // 花括号后直接跟参数列表表示函数调
//输出666

闭包
go的匿名函数就是一个闭包
闭包可以包含自由变量的代码块==》即函数外部变量

j:=10
a:=func(){
	j+=10 //使用了外部变量j
}
//结果j=20

价值：这些函数可以存储到变量中，作为参数传递，并且能动态创建和返回
demo 返回值为一个匿名函数的匿名函数

a := func()(func()) {         //匿名函数1
	var i int = 10         
	return func() {      //匿名函数2       
		fmt.Printf("i, j: %d, %d\n", i, j)         
	}     
}() //立即调用，返回匿名函数2给a
a() //执行a 即匿名函数2

//
错误处理
go语言引入了一个error接口来处理错误如下

type error interface {     
	Error() string 
}

如果函数要返回错误把error作为返回值的最后一个（一般情况）

func Foo(param int)(n int, err error) {     
// ...  
}
//调用
n, err := Foo(0)  
if err != nil {     
// 错误处理 
} else {     
// 使用返回值n  
} 

自定义error

type PathError struct {     
	Op   string 
	Path string     
	Err  error  //包装了一个error类型
}
func (e *PathError) Error() string {     
	return e.Op + " " + e.Path + ": " + e.Err.Error()   
}

//使用：直接把错误信息包装到PathError中
func Stat(name string) (fi FileInfo, err error) {    
	var stat syscall.Stat_t 
    err = syscall.Stat(name, &stat) 
    if err != nil {         
    	return nil, &PathError{"stat", name, err}     
    } 
    return fileInfoFromStat(&stat, name), nil 
} 

///
defer关键字
defer关键字==>延缓函数的执行
使用时在函数或者非法前加defer即可
遇到defer关键字 紧跟其后的函数会被延迟执行
直到包含该defer语句的函数执行完毕时，其后面的函数才会被执行
不论包含defer语句的函数是通过return正常结束，还是由于panic导致的异常结束。
一个函数中允许多个defer，执行顺序与声明顺序相反。
可用于打开、关闭、连接、断开连接、枷锁、释放资源
无论多复杂的的逻辑结构，资源都能被正确释放
释放资源的defer一般跟在请求资源的语句后

defer srcFile.Close()
defer dstFile.Close()
defer func() {     
	// 做你复杂的清理工作 
} ()

///
panic()和recover函数
go语言内置了这两个函数
func panic(interface{})
func recover() interface{}

当调用panic，正常的函数执行流程将立即终止

recover()函数用于处理错误终止

defer func() {     
	if r := recover(); r != nil {         
		log.Printf("Runtime error caught: %v", r)    
	}  
}()

type关键字
1定义结构体

type student struct{
	name string 
	id int
}

2 定义接口

type student interface{
	read()
	write()
}

3类型定义

type str string //以string为基础 定义一个str类型
type getStudent func(id int)//定义一个getStudent类型的方法

4类型别名

type str= string  //把string 取别名为str

类型查询
变量名.(type)

a:="im a boss"
v:=a.(type)
fmt.Println(v)
//结果为string