• error接口

package main

import (
  "errors"
  "fmt"
  "math"
  "os"
)

func main() {
  // 异常情况1
  res := math.Sqrt(-100)
  fmt.Println(res)
  res ,err := Sqrt(-100)
  if err != nil {
    fmt.Println(err)
  } else {
    fmt.Println(res)
  }
  // 异常情况2
  res,err = Divide(10,0)
  if err != nil {
    fmt.Println(err.Error())
  } else {
    fmt.Println(res)
  }
  // 异常情况3 打开不存在的文件
  f, err := os.Open("/abc.txt")
  if err != nil {
    fmt.Println(err)
  } else {
    fmt.Println(f.Name(), "该文件成功被打开")
  }

}

func Sqrt(f float64)(float64, error)  {
  if f < 0 {
    return 0, errors.New("负数不可以获取平方根")
  } else {
    return math.Sqrt(f), nil
  }
}

func Divide(dividee float64, divider float64) (float64, error) {
  if divider == 0 {
      return 0, errors.New("出错，除数不可以为0！")
  } else {
    return dividee / divider, nil
  }
}

• 创建error 对象

package main

import (
  "errors"
  "fmt"
)

func main() {

  // 1.创建error对象的方式1
  err1 := errors.New("自己创建的错误")
  fmt.Println(err1.Error())
  fmt.Println(err1)
  fmt.Printf("err1 的类型：%T\n", err1) // *errors.errorString
  fmt.Println("--------")
  // 2.创建error对象方式2
  err2 := fmt.Errorf("错误的类型%d", 10)
  fmt.Println(err2.Error())
  fmt.Println(err2)
  fmt.Printf("err2 的类型：%T\n", err2) // *errors.errorString
  fmt.Println("--------")

  // error 对象在函数中的使用
  res, err3 := checkAge(-12)
  if err3 != nil {
    fmt.Println(err3.Error())
    fmt.Println(err3)
  } else {
    fmt.Println(res)
  }


}

// 设计一个函数验证年龄，如果是负数，则返回error
func checkAge(age int)(string,error)  {
  if age < 0 {
    err := fmt.Errorf("你输入的年龄是：%d, 该数值为负数，有错误", age)
    return "", err
  } else {
    return fmt.Sprintf("您输入的年龄是 %d", age),nil
  }
}

• 自定义错误

package main

import (
  "fmt"
  "time"
)

// 1.定义结构体，标识自定义错误类型
type MyError struct {
  When time.Time
  What string
}
// 实现Error() 方法
func (e MyError) Error() string  {
  return fmt.Sprintf("%v : %v", e.When, e.What)
}

//3 定义函数，返回error对象。该函数求矩形面积
func getArea(width, length float64) (float64, error)  {
  errorInfo := ""
  if width < 0 && length < 0 {
    errorInfo = fmt.Sprintf("长度：%v , 宽度：%v 均为负数", length,width)
  } else if length < 0 {
    errorInfo = fmt.Sprintf("长度：%v 出现负数", length)
  } else if width < 0 {
    errorInfo = fmt.Sprintf("宽度：%v 出现负数", width)
  }

  if errorInfo != "" {
    return 0, MyError{time.Now(), errorInfo}
  } else {
    return width * length, nil
  }
}

func main() {
  res, err := getArea(-4,-5)
  if err != nil {
    fmt.Printf(err.Error())
  } else {
    fmt.Println("面积为：", res)
  }
}

• panic 示例1

package main

import "fmt"

func TestA()  {
  fmt.Println("func TestA")
}

func TestB()  {
  panic("func TestB panic")
}

func TestC()  {
  fmt.Println("func TestC")
}
func main() {
  TestA()
  TestB() // 发生异常，中断程序
  TestC()
}

• 内置的panic()函数引发的panic异常

package main

import "fmt"

func TestA()  {
  fmt.Println("func TestA")
}

func TestB(x int)  {
  var a [100]int
  a[x] = 1000 // x值为101时，数组越界
}

func TestC()  {
  fmt.Println("func TestC")
}
func main() {
  TestA()
  TestB(101) // 发生异常，中断程序
  TestC()
}

• 需要注意的是，recover()让程序恢复，必须在延迟函数中执行。换言之，recover()仅在延迟函数中有效。

package main

import "fmt"

func funcA()  {
  fmt.Println("这是funcA")
}

func funcB()  {
  defer func() {
    if msg := recover(); msg != nil {
      fmt.Println("恢复啦，获取recover 的返回值：", msg)
    }
  }()
  fmt.Println("这是funcB")
  for i := 0; i<10; i++ {
    fmt.Println("i:", i)
    if i == 5 {
      panic("funcB 恐慌啦")
    }
  }
}

func funcC() {
  defer func() {
    fmt.Println("执行延迟函数")
    msg := recover()
    fmt.Println("获取recover的返回值：",msg)
  }()

  fmt.Println("这是funcC")
  panic("funcC 恐慌了")
}

func main() {
  funcA()
  funcB()
  funcC()
  fmt.Println("main over")
}