GoLang 基础语法（十一）

GoLang 基础语法（十一）

1.错误error

func main() {

	/*f, err := os.Open("test.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(f.Name())*/

	err1 := errors.New("自己创建的错误")
	fmt.Println(err1)
	fmt.Printf("%T\n", err1)

	err2 := fmt.Errorf("错误码%d\n", 101)
	fmt.Println(err2)
	fmt.Printf("%T\n", err2)

	fmt.Println("-----------------------")
	if err3 := CheckAge(20); err3 != nil {
		fmt.Println(err3)
		return
	} else {
		fmt.Println("年龄检测成功!")
	}

}

func CheckAge(age int) error {
	if age < 0 {
		return errors.New("年龄小于0！！！")
	}
	return nil
}

2.错误类型表示（一）

• 使用断言将error接口转换为具体的结构体类型

func main() {
	f, err1 := os.Open("test.txt")
	if err1 != nil {
		fmt.Println(err1)
		if ins, ok := err1.(*os.PathError); ok {
			fmt.Println(ins.Err)
			fmt.Println(ins.Path)
			fmt.Println(ins.Op)
		}
		return
	}
	fmt.Println(f.Name())
}

3.错误类型表示（二）

• 断言后调用结构体中的方法实现错误的逻辑

func main() {
	address, err := net.LookupHost("baidudddd123313dd123.com")
	if err != nil {
		if ins, ok := err.(*net.DNSError); ok {
			if ins.IsTimeout {
				fmt.Println("超时错误")
			} else if ins.IsTemporary {
				fmt.Println("临时错误")
			} else {
				fmt.Println("通常错误")
			}
		}
		return
	}
	fmt.Println(address)
}

4.错误类型表示（三）

• 指定的类型做比较

import (
	"fmt"
	"path/filepath"
)

func main() {
	value, err := filepath.Glob("[")
	if err != nil && err == filepath.ErrBadPattern {
		return
	}
	fmt.Println(value)
}

5.自定义错误（一）

func main() {
	s, err := CircleArea(-2.23)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("圆形的面积是:", s)
}

type AreaError struct {
	msg    string
	radius float64
}

func (a *AreaError) Error() string {
	return fmt.Sprintf("半径:%v,消息:%s\n", a.radius, a.msg)
}
func CircleArea(radius float64) (float64, error) {
	if radius < 0 {
		return 0, &AreaError{msg: "半径是非法的", radius: radius}
	}
	return math.Pi * radius * radius, nil
}

6.自定义错误（二）

func main() {
	s, err := RectArea(-3, -4)
	if err != nil {
		if ins, ok := err.(*MyAreaError); ok {
			if !ins.LengthOk() {
				fmt.Printf("error :长度:%.f,小于零\n", ins.length)
			}
			if !ins.WightOk() {
				fmt.Printf("error :宽度:%.f,小于零\n", ins.weight)
			}
		}
		return
	}
	fmt.Println(s)
}

type MyAreaError struct {
	msg    string
	length float64
	weight float64
}

func (m *MyAreaError) Error() string {
	return m.msg
}
func (m *MyAreaError) LengthOk() bool {
	return m.length > 0
}
func (m *MyAreaError) WightOk() bool {
	return m.weight > 0
}
func RectArea(length float64, weight float64) (float64, error) {
	msg := ""
	if length < 0 {
		msg = "长度小于0"
	}
	if weight < 0 {
		if msg == "" {
			msg = "宽度小于0"
		} else {
			msg += ",宽度小于0"
		}
	}
	if msg != "" {
		return 0, &MyAreaError{msg: msg, length: length, weight: weight}
	}
	return length * weight, nil
}

7.panic和recover

• 发生panic（恐慌）之后的代码都不会继续执行

func main() {
	FuncA()
	defer MyPrint("defer main(): 3...")
	FuncB()
	defer MyPrint("defer main(): 4...")
	fmt.Println("main(): over")
}

func FuncA() {
	fmt.Println("我是一个函数FuncA......")
}

func FuncB() {
	defer func() {
		if msg := recover(); msg != nil {
			fmt.Println("FuncB 恐慌恢复了")
		}
	}()
	fmt.Println("我是一个函数FuncB......")
	defer MyPrint("defer FuncB(): 1...")
	for i := 0; i < 10; i++ {
		fmt.Println("i:", i)
		if i == 5 {
			panic("FuncB 恐慌了")
		}
	}
	defer MyPrint("defer FuncB(): 2...")
}

func MyPrint(s string) {
	fmt.Println(s)
}