errors

package module
v0.0.0-...-c57ad8b Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 5, 2020 License: BSD-3-Clause Imports: 7 Imported by: 1

README

Go errors process

Build Status GoDoc

Install

  1. go get github.com/chai2010/errors
  2. go run hello.go

Example

package main

import (
	"fmt"

	"github.com/chai2010/errors"
)

var (
	e0 = errors.New("err:init0")
	e1 error
	e2 error
)

func init() {
	e1 = errors.New("err:init1")
}

func init() {
	e2 = errors.New("err:init2")
}

func main() {
	var e3 = errors.New("err:main3")
	var e4 = func() error {
		return errors.New("err:main4")
	}()
	var e5 = errors.Wrap(e1, "err:main5")
	var e6 = errors.Wrap(e5, "err:main6")
	var e7 = errors.Wrap(e6, "err:main7")

	fmt.Println(e0, e0.(errors.Error).Caller())
	fmt.Println(e1, e1.(errors.Error).Caller())
	fmt.Println(e2, e2.(errors.Error).Caller())
	fmt.Println(e3, e3.(errors.Error).Caller())
	fmt.Println(e4, e4.(errors.Error).Caller())
	fmt.Println(e5, e5.(errors.Error).Caller())
	fmt.Println(e6, e6.(errors.Error).Caller())

	for i, e := range e7.(errors.Error).Wraped() {
		fmt.Printf("err7: wraped(%d): %v\n", i, e)
	}

	fmt.Println("err7:", e7.(fmt.Stringer).String())
}

Output:

err:init0 [{main.init hello.go 16}]
err:init1 [{main.init.1 hello.go 22} {main.init hello.go 51}]
err:init2 [{main.init.2 hello.go 26} {main.init hello.go 51}]
err:main3 [{main.main hello.go 30}]
err:main4 [{main.main.func1 hello.go 32} {main.main hello.go 33}]
err:main5 -> {err:init1} [{main.main hello.go 34}]
err:main6 -> {err:main5 -> {err:init1}} [{main.main hello.go 35}]
err7: wraped(0): err:main6 -> {err:main5 -> {err:init1}}
err7: wraped(1): err:main5 -> {err:init1}
err7: wraped(2): err:init1
err7: {
	"Code": 0,
	"Error": "err:main7 -> {err:main6 -> {err:main5 -> {err:init1}}}",
	"Caller": [
		{
			"FuncName": "main.main",
			"FileName": "hello.go",
			"FileLine": 36
		}
	],
	"Wraped": [
		{
			"Code": 0,
			"Error": "err:main6 -> {err:main5 -> {err:init1}}",
			"Caller": [
				{
					"FuncName": "main.main",
					"FileName": "hello.go",
					"FileLine": 35
				}
			]
		},
		{
			"Code": 0,
			"Error": "err:main5 -> {err:init1}",
			"Caller": [
				{
					"FuncName": "main.main",
					"FileName": "hello.go",
					"FileLine": 34
				}
			]
		},
		{
			"Code": 0,
			"Error": "err:init1",
			"Caller": [
				{
					"FuncName": "main.init.1",
					"FileName": "hello.go",
					"FileLine": 22
				},
				{
					"FuncName": "main.init",
					"FileName": "hello.go",
					"FileLine": 51
				}
			]
		}
	]
}

BUGS

Report bugs to chaishushan@gmail.com.

Thanks!

Documentation

Overview

Package errors implements functions to manipulate errors.

Example 
package main

import (
	"fmt"

	"github.com/chai2010/errors"
)

func main() {
	err0 := errors.New("err0")
	err1 := errors.Wrap(err0, "err1")
	err2 := func() error { return errors.Wrap(err1, "err2") }()
	err3 := func() error { return errors.Wrap(err2, "err3") }()

	fmt.Println(err0)
	fmt.Println(err1)
	fmt.Println(err2)
	fmt.Println(err3)
}

Output:

err0
err1 -> {err0}
err2 -> {err1 -> {err0}}
err3 -> {err2 -> {err1 -> {err0}}}
Example (Caller) 
package main

import (
	"fmt"

	"github.com/chai2010/errors"
)

func main() {
	err := errors.New("error message")

	fmt.Println(err)
	for i, x := range err.(errors.Error).Caller() {
		fmt.Printf("caller:%d: %s\n", i, x.FuncName)
	}
}

Output:

error message
caller:0: github.com/chai2010/errors_test.Example_caller
caller:1: testing.runExample
caller:2: testing.RunExamples
caller:3: testing.(*M).Run
caller:4: main.main
Example (Code) 
package main

import (
	"fmt"

	"github.com/chai2010/errors"
)

func main() {
	err := errors.NewWithCode(404, "http error code")

	fmt.Println(err)
	fmt.Println(err.(errors.Error).Code())
}

Output:

http error code
404
Example (Json) 
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"reflect"

	"github.com/chai2010/errors"
)

func main() {
	err0 := errors.New("err0")
	err1 := errors.Wrap(err0, "err1")
	err2 := func() error { return errors.Wrap(err1, "err2") }()
	err3 := func() error { return errors.Wrap(err2, "err3") }()

	err3JsonData, err := json.Marshal(err3)
	if err != nil {
		log.Fatal(err)
	}

	errx := errors.MustFromJson(string(err3JsonData))
	if !reflect.DeepEqual(errx, err3) {
		log.Fatal("errors_test.Example_json:", errx, "!=", err3)
	}

	fmt.Println("done")
}

Output:

done
Example (Stringer) 
package main

import (
	"fmt"

	"github.com/chai2010/errors"
)

func main() {
	err0 := errors.New("err0")
	err1 := errors.Wrap(err0, "err1")
	err2 := func() error { return errors.Wrap(err1, "err2") }()
	err3 := func() error { return errors.Wrap(err2, "err3") }()

	fmt.Println(err3)                         // fmt.Println(err3.Error())
	fmt.Println(err3.(fmt.Stringer).String()) // print json string
}

Output:
Example (Wraped) 
package main

import (
	"fmt"
	"runtime"
	"strings"

	"github.com/chai2010/errors"
)

func main() {
	err0 := errors.New("err0")
	err1 := errors.Wrap(err0, "err1")
	err2 := func() error { return errors.Wrap(err1, "err2") }()
	err3 := func() error { return errors.Wrap(err2, "err3") }()

	fmt.Println(err3)
	for j, x := range err3.(errors.Error).Caller() {
		if j == 0 {
			// Closure path is different between Go1.4 and Go1.5
			ver := runtime.Version()
			if strings.HasPrefix(ver, "go1.3") || strings.HasPrefix(ver, "go1.4") {
				if x.FuncName == "github.com/chai2010/errors_test.func" {
					x.FuncName = "github.com/chai2010/errors_test.Example_wraped.func"
				}
			}
		}
		fmt.Printf("caller:%d: %s\n", j, x.FuncName)
	}
	for i, err := range err3.(errors.Error).Wraped() {
		fmt.Printf("wraped:%d: %v\n", i, err)
		for j, x := range err.(errors.Error).Caller() {
			fmt.Printf("    caller:%d: %s\n", j, x.FuncName)
		}
	}
}

Output:

err3 -> {err2 -> {err1 -> {err0}}}
caller:0: github.com/chai2010/errors_test.Example_wraped.func
caller:1: github.com/chai2010/errors_test.Example_wraped
caller:2: testing.runExample
caller:3: testing.RunExamples
caller:4: testing.(*M).Run
caller:5: main.main
wraped:0: err2 -> {err1 -> {err0}}
    caller:0: github.com/chai2010/errors_test.Example_wraped.func
    caller:1: github.com/chai2010/errors_test.Example_wraped
    caller:2: testing.runExample
    caller:3: testing.RunExamples
    caller:4: testing.(*M).Run
    caller:5: main.main
wraped:1: err1 -> {err0}
    caller:0: github.com/chai2010/errors_test.Example_wraped
    caller:1: testing.runExample
    caller:2: testing.RunExamples
    caller:3: testing.(*M).Run
    caller:4: main.main
wraped:2: err0
    caller:0: github.com/chai2010/errors_test.Example_wraped
    caller:1: testing.runExample
    caller:2: testing.RunExamples
    caller:3: testing.(*M).Run
    caller:4: main.main

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func MustFromJson 

func MustFromJson(json string) error

func New 

func New(msg string) error

func NewFrom 

func NewFrom(err error) error

func NewWithCode 

func NewWithCode(code int, msg string) error

func NewWithCodef 

func NewWithCodef(code int, format string, args ...interface{}) error

func Newf 

func Newf(format string, args ...interface{}) error

func ToJson 

func ToJson(err error) string

func Wrap 

func Wrap(err error, msg string) error

func WrapWithCode 

func WrapWithCode(code int, err error, msg string) error

func WrapWithCodef 

func WrapWithCodef(code int, err error, format string, args ...interface{}) error

func Wrapf 

func Wrapf(err error, format string, args ...interface{}) error

Types

type CallerInfo 

type CallerInfo struct {
	FuncName string
	FileName string
	FileLine int
}

func Caller 

func Caller(skip int) []CallerInfo
Example (Skip0) 
package main

import (
	"fmt"

	"github.com/chai2010/errors"
)

func main() {
	skip0Caller := errors.Caller(0)

	fmt.Println(skip0Caller[0].FuncName)
	fmt.Println(skip0Caller[1].FuncName)

}

Output:

github.com/chai2010/errors.Caller
github.com/chai2010/errors_test.ExampleCaller_skip0
Example (Skip1) 
package main

import (
	"fmt"

	"github.com/chai2010/errors"
)

func main() {
	skip1Caller := errors.Caller(1)

	fmt.Println(skip1Caller[0].FuncName)
	fmt.Println(skip1Caller[1].FuncName)

}

Output:

github.com/chai2010/errors_test.ExampleCaller_skip1
testing.runExample

type Error 

type Error interface {
	Caller() []CallerInfo
	Wraped() []error
	Code() int
	error
	// contains filtered or unexported methods
}

func FromJson 

func FromJson(json string) (Error, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.