错误

package main

import (
    "errors"
    "fmt"
)

//43
func main() {
    //f,err := os.Open("test.txt")
    //if err != nil {
    //  // log.Fatal(err) //2020/03/11 10:27:38 open test.txt: The system cannot find the file specified.
    //  fmt.Println(err) //open test.txt: The system cannot find the file specified.
    //  return
    //}
    //fmt.Println(f.Name(),"打开文件成功")

    /*
    error:内置得数据类型，内置的接口
        定义的方法：Error() string

    使用go语言提供好的包：
        errors包下的函数：New(),创建一个error对象
        fmt包下得Errorf()函数：
            func Error(format string,a ...interface{}) error
    */

    err1 := errors.New("自己创建玩的...")
    fmt.Println(err1) //自己创建玩的...
    fmt.Printf("%T\n",err1) //*errors.errorString

    //另一个创建error得方法
    err2 := fmt.Errorf("错误信息码：%d",100)
    fmt.Println(err2)
    fmt.Errorf("%T\n",err2)


    err3 := checkAge(-1)
    if err3 != nil {
        fmt.Println(err3)
        return
    }
    fmt.Println("...........")

}

//设计一个函数，验证年龄是否合法
func checkAge(age int) error {
    if age < 0 {
        return errors.New("年龄不合法")
    }
    fmt.Println("年龄是：",age)
    return nil
}

错误类型表示

package main

import (
    "fmt"
    "os"
)

//44
func main() {

    /*
        错误类型表示
    */

    f,err := os.Open("test.txt")
    if err != nil {
        fmt.Println(err)
        if ins,ok := err.(*os.PathError);ok {
            fmt.Println("1.0p:",ins.Op) //1.0p: open
            fmt.Println("2.Path",ins.Path) //2.Path test.txt
            fmt.Println("3.Err:",ins.Err) //3.Err: The system cannot find the file specified.
        }
        return
    }
    fmt.Println(f.Name(),"打开文件成功")

    

}

package main

import (
    "fmt"
    "net"
    "path/filepath"
)

//45
func main() {

    /*
        错误类型表示
    */

    addr,err := net.LookupHost("www.baidu.com")
    fmt.Println(err)  //<nil>
    if ins,ok := err.(*net.DNSError);ok {
        if ins.Timeout() {
            fmt.Println("操作超时")
        } else if ins.Temporary() {
            fmt.Println("临时性错误")
        } else {
            fmt.Println("通常错误")
        }
    }
    fmt.Println(addr) //[39.156.66.18 39.156.66.14]

    files,err := filepath.Glob("[")
    if err != nil && err == filepath.ErrBadPattern {
        fmt.Println(err) //syntax error in pattern 提供的解析模式错误
        return
    }
    fmt.Println("files:",files)

}

自定义error

package main

import (
    "fmt"
    "math"
)

//46
func main() {

    /*
        自定义error
    */
    radius := -3.0
    area,err := circleArea(radius)
    if err!= nil {
        fmt.Println(err)
        // 使用断言获得非法数据
        if err,ok := err.(*areaError);ok {
            fmt.Printf("半径是：%.2f\n",err.radius)
        }
        return
    }
    fmt.Println("圆形的半径是：",area)


}

//定义一个结构体，表示错误得类型
type areaError struct {
    msg string
    radius float64
}

//2. 实现error接口，就是实现Error()方法
func (e *areaError) Error() string {
    return fmt.Sprintf("error:半径,&.2f,%s",e.radius,e.msg)
}

func circleArea(radius float64)(float64,error) {
    if radius < 0 {
        return 0,&areaError{"半径非法",radius}
    }
    return math.Pi * radius * radius,nil
}

panic和recover

package main

import "fmt"

//47
func main() {

    /*
        panic 和 recover

    */

    funA()
    defer myprint("defer main3......")

    funB()
    defer myprint("defer main4......")

    fmt.Println("main over...")

}

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

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

func funB() { //外围函数

    defer func() {
        if msg := recover();msg != nil {
            fmt.Println(msg,"程序恢复了")
        }
    }()

    fmt.Println("我是函数funB")
    defer myprint("defer funB()1.....")
    for i:=1;i<=10;i++ {
        fmt.Println("i:",i)
        //让程序中断
        if i == 5 {
            panic("funB函数，恐慌")
        }
    }
    //当外围函数代码中发生了恐慌，只有其中所有的defer得函数全部执行完毕后，才会被传到函数的调用出
    defer myprint("defer funB()2.....")
}