1
2
3
4
5

// The error built-in interface type is the conventional interface for
// representing an error condition, with the nil value representing no error.
type error interface {
	Error() string
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package errors

// New returns an error that formats as the given text.
func New(text string) error {
	return &errorString{text}
}

// errorString is a trivial implementation of error.
type errorString struct {
	s string
}

func (e *errorString) Error() string {
	return e.s
}

1
2
3
4
5

// Errorf formats according to a format specifier and returns the string
// as a value that satisfies error.
func Errorf(format string, a ...interface{}) error {
	return errors.New(Sprintf(format, a...))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func demo(i, k int) (d int, e error) {
	if k == 0 {
		e = errors.New("初始不能为0")
		d=0
		return
	}
	d = i / k
	return
}

func main() {
	result,error:=demo(6,0)
	fmt.Println(result,error)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func demo(i, k int) (d int, e error) {
	if k == 0 {
		e = fmt.Errorf("%s%d和%d", "除数不能是0,两个参数分别是:", i, k)
		d = 0
		return
	}
	d = i / k
	return
}

func main() {
	result, error := demo(6, 0)
	fmt.Println(result, error)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func demo(i, k int) (d int, e error) {
	if k == 0 {
		e = fmt.Errorf("%s%d和%d", "除数不能是0,两个参数分别是:", i, k)
		d = 0
		return
	}
	d = i / k
	return
}

func main() {
	result, _ := demo(6, 0)
	fmt.Println(result)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

func demo(i, k int) (d int, e error) {
	if k == 0 {
		e = fmt.Errorf("%s%d和%d", "除数不能是0,两个参数分别是:", i, k)
		d = 0
		return
	}
	d = i / k
	return
}

func main() {
	result, error := demo(6, 0)
	if error != nil {
		fmt.Println("发生错误", error)
		return
	}
	fmt.Println("程序执行成功,结果为:", result)
}

1
2
3
4
5
6
7
8

func main() {
   fmt.Println("打开连接")
   defer func(){
      fmt.Println("关闭连接")
   }()
   fmt.Println("进行操作")
   //输出:打开连接 进行操作 关闭连接
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func main() {
   fmt.Println("打开连接A")
   defer func(){
      fmt.Println("关闭连接A")
   }()
   fmt.Println("打开连接B")
   defer func(){
      fmt.Println("关闭连接B")
   }()
   fmt.Println("进行操作")
   //输出:打开连接A 打开连接B 进行操作 关闭连接B 关闭连接A
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func f() int{
	i:=0
	defer func(){
		i=i+2
	}()
	return i
}

func main() {
	fmt.Println(f())//输出:0
}

1
2
3
4
5
6
7
8
9

func f() (i int){
	defer func(){
		i=i+2
	}()
	return
}
func main() {
	fmt.Println(f())//输出:2
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// The panic built-in function stops normal execution of the current
// goroutine. When a function F calls panic, normal execution of F stops
// immediately. Any functions whose execution was deferred by F are run in
// the usual way, and then F returns to its caller. To the caller G, the
// invocation of F then behaves like a call to panic, terminating G's
// execution and running any deferred functions. This continues until all
// functions in the executing goroutine have stopped, in reverse order. At
// that point, the program is terminated and the error condition is reported,
// including the value of the argument to panic. This termination sequence
// is called panicking and can be controlled by the built-in function
// recover.
func panic(v interface{})

1
2
3
4
5

func main() {
   fmt.Println("1")
   panic("panic执行了,哈哈")
   fmt.Println("2")
}

1
2
3
4
5
6

1
panic: panic执行了,哈哈

goroutine 1 [running]:
main.main()
	D:/gowork/c/main.go:7 +0x80

1
2
3
4
5
6
7
8

func main() {
   defer func(){
      fmt.Println("defer执行")
   }()
   fmt.Println("1")
   panic("panic执行了,哈哈")
   fmt.Println("2")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// The recover built-in function allows a program to manage behavior of a
// panicking goroutine. Executing a call to recover inside a deferred
// function (but not any function called by it) stops the panicking sequence
// by restoring normal execution and retrieves the error value passed to the
// call of panic. If recover is called outside the deferred function it will
// not stop a panicking sequence. In this case, or when the goroutine is not
// panicking, or if the argument supplied to panic was nil, recover returns
// nil. Thus the return value from recover reports whether the goroutine is
// panicking.
func recover() interface{}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func main() {
	defer func() {
		if error:=recover();error!=nil{
			fmt.Println("出现了panic,使用reover获取信息:",error)
		}
	}()
	fmt.Println("11111111111")
	panic("出现panic")
	fmt.Println("22222222222")
}

1
2

11111111111
出现了panic,使用reover获取信息: 出现panic

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

func demo1(){
	fmt.Println("demo1上半部分")
	demo2()
	fmt.Println("demo1下半部分")
}
func demo2(){
	defer func() {
		recover()//此处进行恢复
	}()
	fmt.Println("demo2上半部分")
	demo3()
	fmt.Println("demo2下半部分")
}
func demo3(){
	fmt.Println("demo3上半部分")
	panic("在demo3出现了panic")
	fmt.Println("demo3下半部分")
}
func main() {
	fmt.Println("程序开始")
	demo1()
	fmt.Println("程序结束")
}