package main

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


func Sqrt(f float64) (float64, error) {
   if f < 0 {
      return 0, errors.New("同学，这是负数呀！")
   } else {
      return math.Sqrt(f), nil
   }
}

func main() {
   //异常情况
   res := math.Sqrt(-100)
   fmt.Println(res) //NaN，也就是Not-a-Number，非数，不是数。NaN不是一个非数，而是一类非数。

   //使用自己定义的异常错误,直接打印错误信息
   res, err := Sqrt(-100)
   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(res)
   }

   //err.Error()，输出错误信息
   res, err = Sqrt(-10)
   if err != nil {
      fmt.Println(err.Error())
   } else {
      fmt.Println(res)
   }
}

// Errorf formats according to a format specifier and returns the string as a
// value that satisfies error.
//
// If the format specifier includes a %w verb with an error operand,
// the returned error will implement an Unwrap method returning the operand. It is
// invalid to include more than one %w verb or to supply it with an operand
// that does not implement the error interface. The %w verb is otherwise
// a synonym for %v.
func Errorf(format string, a ...interface{}) error {
	p := newPrinter()
	p.wrapErrs = true
	p.doPrintf(format, a)
	s := string(p.buf)
	var err error
	if p.wrappedErr == nil {
		err = errors.New(s)
	} else {
		err = &wrapError{s, p.wrappedErr}
	}
	p.free()
	return err
}

type MyError struct {
   When time.Time
   What string
}

func (e MyError) Error() string {
   return fmt.Sprintf("%v : %v", e.When, e.What)
}

func Sqrt(f float64) (float64, error) {
   errorInfo := ""
   if f < 0 {
      errorInfo = fmt.Sprintf("不能为负数 %v ", f)
   }

   if errorInfo != "" {
      return 0, MyError{time.Now(), errorInfo}
   } else {
      return math.Sqrt(f), nil
   }
}

func main() {
   sqrt, err := Sqrt(-100)
   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(sqrt)
   }
}

/**
1.defer 会在函数结束前输出，return,panic执行之前
2.如果多出defer.会按照栈排列输出，先进后出
*/

func tryDefer() {
	defer fmt.Println(1)
	defer fmt.Println(2)
	fmt.Println(3)
}

func main() {
	tryDefer()
}

func main() {
   str := "利用defer实现字符串倒序"
   fmt.Println(str)
   ReverseString(str)
}

func ReverseString(str string) {
   for _, c := range []rune(str) {
      defer fmt.Printf("%c", c)
   }
}

func testFunc(){
	defer func(){
		msg := recover();
		fmt.Println("获取recover的返回值: ",msg)
	}()
	fmt.Println("panic 前")
	panic("调用panic")
}

/**
  @Go version: 1.17.6
  @project: TeachCode
  @ide: GoLand
  @file: errorTest.go
  @author: Lido
  @time: 2022-02-20 22:55
  @description:
*/
package main

import (
	"errors"
	"fmt"
)

func f1(arg int) (int, error) {
	if arg == 42 {

		return -1, errors.New("can't work with 42")

	}

	return arg + 3, nil
}

type argError struct {
	arg  int
	prob string
}

func (e argError) Error() string {
	return fmt.Sprintf("%d - %s", e.arg, e.prob)
}

func f2(arg int) (int, error) {
	if arg == 42 {
		return -1, argError{arg, "can't work with it"}
	}
	return arg + 3, nil
}

func main() {

	for _, i := range []int{7, 42} {
		if r, e := f1(i); e != nil {
			fmt.Println("f1 failed:", e)
		} else {
			fmt.Println("f1 worked:", r)
		}
	}
	for _, i := range []int{7, 42} {
		if r, e := f2(i); e != nil {
			fmt.Println("f2 failed:", e)
		} else {
			fmt.Println("f2 worked:", r)
		}
	}

	_, e := f2(42)
	/*
	   如果你想在程序中使用自定义错误类型的数据，
	   你需要通过类型断言来得到这个自定义错误类型的实例。
	*/
	if ae, ok := e.(argError); ok {
		fmt.Println(ae.arg)
		fmt.Println(ae.prob)
	}
}

func calcTriangle(a, b int) int {
	var c int
	c = int(math.Sqrt(float64(a*a + b*b)))
	return c
}

package main

import "testing"

func Test_Triangle(t *testing.T) {
	tests := []struct{ a, b, c int }{
		{3, 4, 5},
		{5, 12, 13},
		{8, 15, 17},
		{12, 35, 37},
		{30000, 40000, 50000},
	}

	for _, tt := range tests {
		if actual := calcTriangle(tt.a, tt.b); actual != tt.c {
			t.Errorf("calcTriangle(%d, %d); "+
				"got %d; expected %d",
				tt.a, tt.b, actual, tt.c)
		}
	}
}

//先cd 到文件目录下
go test .

//生成检测结果
go test -coverprofile=c.out

//查看检测结果
go tool cover -html=c.out

func BenchmarkSubStr(b *testing.B) {
	a := 3
	b := 4
	ans := 5

	for i := 0; i < b.N; i++ {
		actual := calcTriangle(a,b)
		if actual != ans {
			b.Errorf("got %d for input %s; "+
				"expected %d",
				actual, s, ans)
		}
	}
}

go test -bench .

go run -race xxx.go

go doc Queue

go get golang.org/x/tools/cmd/godoc

godoc -http :6060

package queue

import (
	"fmt"
)

func ExampleQueue_Pop() {
	q := Queue{1}

	q.Push(2)
	q.Push(3)
	fmt.Println(q.Pop())
	fmt.Println(q.Pop())
	fmt.Println(q.IsEmpty())
	fmt.Println(q.Pop())
	fmt.Println(q.IsEmpty())

	q.Push("abc")
	fmt.Println(q.Pop())

	// Output:
	// 1
	// 2
	// false
	// 3
	// true
	// abc
}

godoc -http :6060