├── .travis.yml
├── example
├── images
│ └── display.png
└── example.go
├── constant.go
├── joint_darwin.go
├── joint_linux.go
├── joint_windows.go
├── log_factory.go
├── log.go
├── README.md
├── log_test.go
├── print_darwin.go
├── print_linux.go
└── print_windows.go
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 |
3 | go:
4 | - 1.11.x
--------------------------------------------------------------------------------
/example/images/display.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/corgi-kx/logcustom/HEAD/example/images/display.png
--------------------------------------------------------------------------------
/constant.go:
--------------------------------------------------------------------------------
1 | package log
2 |
3 | //默认是否彩色打印
4 | var isColor = true
5 |
6 | type logType int
7 |
8 | //日志等级
9 | const (
10 | Leveltrace logType = iota //基本输出,
11 | Levelinfo //系统信息
12 | Leveldebug //系统调试
13 | Levelwarn //系统警告,提示有可预测的错误
14 | Levelerror //程序错误,不影响继续使用
15 | Levelpanic //程序异常，递归调用本层及上层defer后，中断程序进程，类似java的异常处理
16 | Levelfatal //程序直接结束，打印错误信息后直接调用os.Exit(1)结束程序，不会调用各层defer
17 | )
18 |
19 | type colorType uint8
20 |
21 | //日志打印颜色
22 | const (
23 | colorBlack colorType = iota + 30
24 | colorRed //红色
25 | colorGreen //绿色
26 | colorYellow //黄色
27 | colorBlue //蓝色
28 | colorPurple //紫色
29 | colorDarkblue //碧蓝
30 | )
31 |
32 | //日志打印颜色
33 | const (
34 | WinColorBlue colorType = iota + 9 //蓝色
35 | WinColorGreen //绿色
36 | WinColorDarkblue //碧蓝
37 | WinColorRed //红色
38 | WinColorPurple //紫色
39 | WinColorYellow //黄色
40 | )
41 |
42 | //日志头部标志
43 | const (
44 | lTrace = "[TRACE]"
45 | lInfo = "[INFO]"
46 | lDebug = "[DEBUG]"
47 | lWarn = "[WARN]"
48 | lError = "[ERROR]"
49 | lPanic = "[PANIC]"
50 | lFatal = "[FATAL]"
51 | )
52 |
--------------------------------------------------------------------------------
/joint_darwin.go:
--------------------------------------------------------------------------------
1 | package log
2 |
3 | import (
4 | "fmt"
5 | "path/filepath"
6 | "runtime"
7 | "strings"
8 | "time"
9 | )
10 |
11 | //传入要打印的信息，拼接好后返回
12 | func joint(prefix, message string, color colorType) string {
13 | now := time.Now().Format("2006/01/02 15:04:05")
14 | filename, funcname, line := getpProcInfo()
15 | s := fmt.Sprint(prefix, ": ", now, " ", filename, ":", line, ":", funcname, ": ", message)
16 | if isColor {
17 | //s = fmt.Sprintf("\x1b[%dm%s\x1b[0m", color, s)
18 | s = fmt.Sprintf("\033[%dm%s\033[0m", color, s)
19 | }
20 | return s
21 | }
22 |
23 | func (l mylog) joint(prefix, message string, color colorType) string {
24 | now := time.Now().Format("2006/01/02 15:04:05")
25 | filename, funcname, line := getpProcInfo()
26 | s := fmt.Sprint(prefix, ": ", now, " ", filename, ":", line, ":", funcname, ": ", message)
27 | if l.isColor {
28 | //s = fmt.Sprintf("\x1b[%dm%s\x1b[0m", color, s)
29 | s = fmt.Sprintf("\033[%dm%s\033[0m", color, s)
30 | }
31 | return s
32 | }
33 |
34 | //获取打印日志的进程信息
35 | func getpProcInfo() (filename, funcname string, line int) {
36 | pc, filename, line, ok := runtime.Caller(3)
37 | if ok {
38 | funcname = runtime.FuncForPC(pc).Name() // main.(*MyStruct).foo
39 | funcname = filepath.Ext(funcname) // .foo
40 | funcname = strings.TrimPrefix(funcname, ".") // foo
41 | filename = filepath.Base(filename) // /full/path/basename.go => basename.go
42 | }
43 | return
44 | }
45 |
--------------------------------------------------------------------------------
/joint_linux.go:
--------------------------------------------------------------------------------
1 | package log
2 |
3 | import (
4 | "fmt"
5 | "path/filepath"
6 | "runtime"
7 | "strings"
8 | "time"
9 | )
10 |
11 | //传入要打印的信息，拼接好后返回
12 | func joint(prefix, message string, color colorType) string {
13 | now := time.Now().Format("2006/01/02 15:04:05")
14 | filename, funcname, line := getpProcInfo()
15 | s := fmt.Sprint(prefix, ": ", now, " ", filename, ":", line, ":", funcname, ": ", message)
16 | if isColor {
17 | //s = fmt.Sprintf("\x1b[%dm%s\x1b[0m", color, s)
18 | s = fmt.Sprintf("\033[%dm%s\033[0m", color, s)
19 | }
20 | return s
21 | }
22 |
23 | func (l mylog) joint(prefix, message string, color colorType) string {
24 | now := time.Now().Format("2006/01/02 15:04:05")
25 | filename, funcname, line := getpProcInfo()
26 | s := fmt.Sprint(prefix, ": ", now, " ", filename, ":", line, ":", funcname, ": ", message)
27 | if l.isColor {
28 | //s = fmt.Sprintf("\x1b[%dm%s\x1b[0m", color, s)
29 | s = fmt.Sprintf("\033[%dm%s\033[0m", color, s)
30 | }
31 | return s
32 | }
33 |
34 | //获取打印日志的进程信息
35 | func getpProcInfo() (filename, funcname string, line int) {
36 | pc, filename, line, ok := runtime.Caller(3)
37 | if ok {
38 | funcname = runtime.FuncForPC(pc).Name() // main.(*MyStruct).foo
39 | funcname = filepath.Ext(funcname) // .foo
40 | funcname = strings.TrimPrefix(funcname, ".") // foo
41 | filename = filepath.Base(filename) // /full/path/basename.go => basename.go
42 | }
43 | return
44 | }
45 |
--------------------------------------------------------------------------------
/example/example.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | log "github.com/corgi-kx/logcustom"
5 | "os"
6 | )
7 |
8 | func main() {
9 | log.Info("Write something you want to print !")
10 | log.Warn("Write something you want to print !")
11 | log.Trace("Write something you want to print !")
12 | log.Debug("Write something you want to print !")
13 | log.Error("Write something you want to print !")
14 |
15 | //设置输出信息隐藏等级
16 | err := log.SetLogDiscardLevel(log.Leveldebug)
17 | if err != nil {
18 | log.Error(err)
19 | }
20 |
21 | log.Info("SetLogDiscardLevel test !") //INFO不会被打印
22 | log.Debug("SetLogDiscardLevel test !")
23 | log.Warn("SetLogDiscardLevel test !")
24 |
25 | //创建新的日志对象
26 | mylog := log.New()
27 | file, err := os.OpenFile("log.txt", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666)
28 | if err != nil {
29 | log.Error(err)
30 | }
31 | //将日志信息输出到指定文件
32 | mylog.SetOutputAbove(file, log.Levelwarn) //WARN及WARN以上级别的日志会输出到指定文件
33 | mylog.Trace("SetOutputAll test !")
34 | mylog.Info("SetOutputAll test !")
35 | mylog.Debug("SetOutputAll test !")
36 | mylog.Warn("SetOutputAll test !")
37 | mylog.Error("SetOutputAll test !")
38 | }
39 |
40 | //func DisplayEffect () {
41 | // log.Info("Write something you want to print !")
42 | // log.Warn("Write something you want to print !")
43 | // log.Trace("Write something you want to print !")
44 | // log.Debug("Write something you want to print !")
45 | // log.Error("Write something you want to print !")
46 | // log.Fatal("Write something you want to print !")
47 | //}
48 |
--------------------------------------------------------------------------------
/joint_windows.go:
--------------------------------------------------------------------------------
1 | package log
2 |
3 | import (
4 | "fmt"
5 | "path/filepath"
6 | "runtime"
7 | "strings"
8 | "syscall"
9 | "time"
10 | )
11 |
12 | //传入要打印的信息，拼接好后返回
13 | func joint(prefix, message string, color colorType) string {
14 | now := time.Now().Format("2006/01/02 15:04:05")
15 | filename, funcname, line := getpProcInfo()
16 | s := fmt.Sprint(prefix, ": ", now, " ", filename, ":", line, ":", funcname, ": ", message)
17 | //如果是windows系统彩色打印，需要调试kernel32.dll文件
18 | if isColor {
19 | winKernelOpen(color)
20 | }
21 | return s
22 | }
23 |
24 | func (l mylog) joint(prefix, message string, color colorType) string {
25 | now := time.Now().Format("2006/01/02 15:04:05")
26 | filename, funcname, line := getpProcInfo()
27 | s := fmt.Sprint(prefix, ": ", now, " ", filename, ":", line, ":", funcname, ": ", message)
28 | if l.isColor {
29 | winKernelOpen(color)
30 | }
31 | return s
32 | }
33 |
34 | //传入颜色代码，windows系统开启彩色打印
35 | func winKernelOpen(color colorType) {
36 | kernel32 := syscall.NewLazyDLL("kernel32.dll")
37 | proc := kernel32.NewProc("SetConsoleTextAttribute")
38 | proc.Call(uintptr(syscall.Stdout), uintptr(color))
39 | }
40 |
41 | //windows系统关闭彩色打印
42 | func winKernelColse() {
43 | kernel32 := syscall.NewLazyDLL("kernel32.dll")
44 | proc := kernel32.NewProc("SetConsoleTextAttribute")
45 | handle, _, _ := proc.Call(uintptr(syscall.Stdout), uintptr(7))
46 | CloseHandle := kernel32.NewProc("CloseHandle")
47 | CloseHandle.Call(handle)
48 | }
49 |
50 | //获取打印日志的进程信息
51 | func getpProcInfo() (filename, funcname string, line int) {
52 | pc, filename, line, ok := runtime.Caller(3)
53 | if ok {
54 | funcname = runtime.FuncForPC(pc).Name() // main.(*MyStruct).foo
55 | funcname = filepath.Ext(funcname) // .foo
56 | funcname = strings.TrimPrefix(funcname, ".") // foo
57 | filename = filepath.Base(filename) // /full/path/basename.go => basename.go
58 | }
59 | return
60 | }
61 |
--------------------------------------------------------------------------------
/log_factory.go:
--------------------------------------------------------------------------------
1 | package log
2 |
3 | import (
4 | "errors"
5 | "io"
6 | "io/ioutil"
7 | "log"
8 | "os"
9 | )
10 |
11 | type mylog struct {
12 | loggers []*log.Logger
13 | isColor bool
14 | }
15 |
16 | //生成一个新的日志对象
17 | func New() mylog {
18 | loggers := []*log.Logger{
19 | Leveltrace: log.New(os.Stdout, "", 0),
20 | Levelinfo: log.New(os.Stdout, "", 0),
21 | Leveldebug: log.New(os.Stdout, "", 0),
22 | Levelwarn: log.New(os.Stderr, "", 0),
23 | Levelerror: log.New(os.Stderr, "", 0),
24 | Levelpanic: log.New(os.Stderr, "", 0),
25 | Levelfatal: log.New(os.Stderr, "", 0),
26 | }
27 | return mylog{loggers, true}
28 | }
29 |
30 | /*
31 | 隐藏单个日志级别的输出
32 | 日志级别不能超过Levelpanic
33 | */
34 | func (l mylog) SetLogDiscard(t logType) error {
35 | if t > Levelpanic {
36 | return errors.New("SetLevel err: can't set log level Discard > Levelerror")
37 | }
38 | l.loggers[t].SetOutput(ioutil.Discard)
39 | return nil
40 | }
41 |
42 | //设置隐藏日志等级
43 | //最高设置到Levelpanic 即是低于panic等级的日志都不显示
44 | func (l mylog) SetLogDiscardLevel(t logType) error {
45 | if t > Levelpanic {
46 | return errors.New("SetLevel err: can't set log level Discard more than Levelerror")
47 | }
48 | for i := int(t); i >= 0; i-- {
49 | if i <= 3 {
50 | l.loggers[logType(i)].SetOutput(os.Stdout)
51 | } else {
52 | l.loggers[logType(i)].SetOutput(os.Stderr)
53 | }
54 | }
55 | for i := 0; i < int(t); i++ {
56 | l.loggers[logType(i)].SetOutput(ioutil.Discard)
57 | }
58 | return nil
59 | }
60 |
61 | //是否彩色打印
62 | func (l *mylog) IsColor(iscolor bool) {
63 | l.isColor = iscolor
64 | }
65 |
66 | //设置单个日志级别输出到目标位置
67 | func (l mylog) SetOutput(w io.Writer, t logType) {
68 | l.loggers[t].SetOutput(w)
69 | }
70 |
71 | //设置全部日志级别输出到目的地
72 | func (l mylog) SetOutputAll(w io.Writer) {
73 | for i := range l.loggers {
74 | l.loggers[i].SetOutput(w)
75 | }
76 | }
77 |
78 | //设置指定日志级别及以上的输出到目标位置
79 | func (l mylog) SetOutputAbove(w io.Writer, t logType) {
80 | for i := int(t); i < 7; i++ {
81 | l.loggers[logType(i)].SetOutput(w)
82 | }
83 | }
84 |
85 | //设置指定日志级别及以下的输出到目标位置
86 | func (l mylog) SetOutputBelow(w io.Writer, t logType) {
87 | for i := 0; i <= int(t); i++ {
88 | l.loggers[logType(i)].SetOutput(w)
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/log.go:
--------------------------------------------------------------------------------
1 | package log
2 |
3 | import (
4 | "errors"
5 | "io"
6 | "io/ioutil"
7 | "log"
8 | "os"
9 | )
10 |
11 | /*
12 | 默认设置：
13 | 0 - 2层信息输出到os.stdout
14 | 3 - 6层信息输出到os.stderr
15 | */
16 | var loggers = []*log.Logger{
17 | Leveltrace: log.New(os.Stdout, "", 0),
18 | Levelinfo: log.New(os.Stdout, "", 0),
19 | Leveldebug: log.New(os.Stdout, "", 0),
20 | Levelwarn: log.New(os.Stderr, "", 0),
21 | Levelerror: log.New(os.Stderr, "", 0),
22 | Levelpanic: log.New(os.Stderr, "", 0),
23 | Levelfatal: log.New(os.Stderr, "", 0),
24 | }
25 |
26 | //是否彩色打印
27 | func IsColor(iscolor bool) {
28 | isColor = iscolor
29 | }
30 |
31 | //SetLogDiscard隐藏单个日志级别的输出信息
32 | //传入需要隐藏的日志级别，日志级别不能超过Levelpanic
33 | func SetLogDiscard(t logType) error {
34 | if t > Levelpanic {
35 | return errors.New("SetLevel err: can't set log level Discard > Levelerror")
36 | }
37 | loggers[t].SetOutput(ioutil.Discard)
38 | return nil
39 | }
40 |
41 | //SetLogDiscardLevel隐藏多个日志级别输出信息
42 | //传入需要隐藏的日志级别，最高设置到Levelpanic 即是低于panic等级的日志都不显示
43 | func SetLogDiscardLevel(t logType) error {
44 | if t > Levelpanic {
45 | return errors.New("SetLevel err: can't set log level Discard more than Levelerror")
46 | }
47 | for i := int(t); i >= 0; i-- {
48 | if i <= 3 {
49 | loggers[logType(i)].SetOutput(os.Stdout)
50 | } else {
51 | loggers[logType(i)].SetOutput(os.Stderr)
52 | }
53 | }
54 | for i := 0; i < int(t); i++ {
55 | loggers[logType(i)].SetOutput(ioutil.Discard)
56 | }
57 | return nil
58 | }
59 |
60 | //SetOutput设置单个日志级别输出到目标位置
61 | //传入文件的句柄（或者实现了io.Writer接口的对象）与日志级别，则该日志级别的日志将会输出到指定的文件或位置
62 | func SetOutput(w io.Writer, t logType) {
63 | loggers[t].SetOutput(w)
64 | }
65 |
66 | //SetOutputAll设置全部日志级别输出到目标位置
67 | //传入文件的句柄（或者实现了io.Writer接口的对象）与日志级别，则全部日志级别的日志将会输出到指定的文件或位置
68 | func SetOutputAll(w io.Writer) {
69 | for i := range loggers {
70 | loggers[i].SetOutput(w)
71 | }
72 | }
73 |
74 | //SetOutputAbove设置指定日志级别及以上的输出到目标位置
75 | //传入文件的句柄（或者实现了io.Writer接口的对象）与日志级别，则该日志级别以上的日志（包括此日志级别）将会输出到指定的文件或位置
76 | func SetOutputAbove(w io.Writer, t logType) {
77 | for i := int(t); i < 7; i++ {
78 | loggers[logType(i)].SetOutput(w)
79 | }
80 | }
81 |
82 | //SetOutputBelow设置指定日志级别及以下的输出到目标位置
83 | //传入文件的句柄（或者实现了io.Writer接口的对象）与日志级别，则该日志级别以下的日志（包括此日志级别）将会输出到指定的文件或位置
84 | func SetOutputBelow(w io.Writer, t logType) {
85 | for i := 0; i <= int(t); i++ {
86 | loggers[logType(i)].SetOutput(w)
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # golang日志小工具
2 |
3 | [](https://travis-ci.org/corgi-kx)
4 |
5 |
6 | 花了几天时间写了个golang日志小工具，基本满足日常开发需求
7 |
8 | **特点**
9 | - 支持定向输出日志到指定文件
10 | - 支持隐藏调试信息
11 | - 支持彩色打印（windows/linux/mac均支持）
12 | - 显示输出日志的类名、函数/方法名
13 |
14 |
15 |
16 | **Feature**
17 | - Supports directing output logs to specified files
18 | - Support for hiding debugging information
19 | - Support color printing (Windows/Linux/MAC)
20 | - Displays the class name, function/method name of the output log
21 |
22 |
23 |
24 | **源码地址：**
25 | [https://github.com/corgi-kx/logcustom](https://github.com/corgi-kx/logcustom)
26 |
27 |
28 |
29 |
30 | ### 示例 Example
31 |
32 |
33 | 打印效果：
34 |
35 | [](example/example.go)
36 |
37 | [使用示范](example/example.go)：
38 | ```go
39 | package main
40 |
41 | import (
42 | log "github.com/corgi-kx/logcustom"
43 | "os"
44 | )
45 |
46 | func main() {
47 | //直接调用log，则是全局使用
48 | log.Info("Write something you want to print !")
49 | log.Warn("Write something you want to print !")
50 | log.Trace("Write something you want to print !")
51 | log.Debug("Write something you want to print !")
52 | log.Error("Write something you want to print !")
53 |
54 | //设置输出信息隐藏等级
55 | err := log.SetLogDiscardLevel(log.Leveldebug)
56 | if err != nil {
57 | log.Error(err)
58 | }
59 |
60 | log.Info("SetLogDiscardLevel test !") //INFO不会被打印
61 | log.Debug("SetLogDiscardLevel test !")
62 | log.Warn("SetLogDiscardLevel test !")
63 |
64 | //创建新的日志对象
65 | mylog := log.New()
66 | file, err := os.OpenFile("log.txt", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666)
67 | if err != nil {
68 | log.Error(err)
69 | }
70 | //将日志信息输出到指定文件
71 | mylog.SetOutputAbove(file, log.Levelwarn) //WARN及WARN以上级别的日志会输出到指定文件
72 | mylog.Trace("SetOutputAll test !")
73 | mylog.Info("SetOutputAll test !")
74 | mylog.Debug("SetOutputAll test !")
75 | mylog.Warn("SetOutputAll test !")
76 | mylog.Error("SetOutputAll test !")
77 | }
78 |
79 | ```
80 |
81 |
82 | ### 安装 Installing
83 |
84 |
85 | ```shell
86 | go get github.com/corgi-kx/logcustom
87 | ```
88 | 安装成功后，日志包就可以使用了，包位置在
89 | ```shell
90 | $GOPATH/src/github.com/corgi-kx/logcustom
91 | ```
92 |
93 | 您可以使用 `go get -u` 对此包进行更新
94 |
95 |
96 | ### 文档 Documentation
97 |
98 |
99 | 您可以使用以下命令来查看使用文档
100 | ```shell
101 | godoc github.com/corgi-kx/logcustom
102 | ```
103 | 或者在终端输入如下命令：
104 | ```shell
105 | godoc -http=:6060
106 | ```
107 | 在浏览器访问此界面
108 | ```shell
109 | http://127.0.0.1:6060/pkg/github.com/corgi-kx/logcustom/
110 | ```
111 |
--------------------------------------------------------------------------------
/log_test.go:
--------------------------------------------------------------------------------
1 | package log
2 |
3 | import (
4 | "fmt"
5 | "github.com/stretchr/testify/assert"
6 | "log"
7 | "os"
8 | "strconv"
9 | "sync"
10 | "testing"
11 | "time"
12 | )
13 |
14 | func TestLogPrint(t *testing.T) {
15 | t.Log("测试打印效果")
16 | {
17 | IsColor(false)
18 | Warn("测试打印效果Warn")
19 | Info("测试打印效果Info")
20 | Debug("测试打印效果Info")
21 | Trace("测试打印效果Trace")
22 | Error("测试打印效果Error")
23 | //Panic("测试打印效果Panic")
24 | //Fatal("测试打印效果Fatal")
25 | IsColor(true)
26 | Trace("测试打印效果Trace")
27 | Tracef("%s", "测试打印效果Tracef")
28 | Info("测试打印效果Info")
29 | Infof("%s", "测试打印效果Infof")
30 | Debug("测试打印效果Info")
31 | Debugf("%s", "测试打印效果Debugf")
32 | Warn("测试打印效果Warn")
33 | Warnf("%s", "测试打印效果Warnf")
34 | Error("测试打印效果Error")
35 | Errorf("%s", "测试打印效果Errorf")
36 | SetLogDiscard(Levelwarn)
37 | Warn("测试打印效果Warn")
38 | Warnf("%s", "测试打印效果Warnf")
39 | //Fatal("测试打印效果Fatal")
40 | //Panic("测试打印效果Panic")
41 | mylog := New()
42 | mylog.Trace("mylog测试打印效果Trace")
43 | mylog.Tracef("%s", "mylog测试打印效果Tracef")
44 | mylog.Info("mylog测试打印效果Info")
45 | mylog.Infof("%s", "mylog测试打印效果Infof")
46 | mylog.Debug("mylog测试打印效果Info")
47 | mylog.Debugf("%s", "mylog测试打印效果Debugf")
48 | mylog.Warn("mylog测试打印效果Warn")
49 | mylog.Warnf("%s", "mylog测试打印效果Warnf")
50 | mylog.Error("mylog测试打印效果Error")
51 | mylog.Errorf("%s", "mylog测试打印效果Errorf")
52 | mylog2 := New()
53 | mylog2.IsColor(true)
54 | mylog2.SetLogDiscardLevel(Levelerror)
55 | mylog2.Trace("mylog2测试打印效果Trace")
56 | mylog2.Tracef("%s", "mylog2测试打印效果Tracef")
57 | mylog2.Info("测试打印效果Info")
58 | mylog2.Infof("%s", "mylog2测试打印效果Infof")
59 | mylog2.Debug("测试打印效果Debug")
60 | mylog2.Debugf("%s", "mylog2测试打印效果Debugf")
61 | mylog2.Warn("测试打印效果Warn")
62 | mylog2.Warnf("%s", "mylog2测试打印效果Warnf")
63 | mylog2.Error("测试打印效果Error")
64 | mylog2.Errorf("%s", "mylog2测试打印效果Errorf")
65 | }
66 | }
67 |
68 | func TestLogMultithread(t *testing.T) {
69 | t.Log("测试日志是否线程安全")
70 | {
71 | wait := sync.WaitGroup{}
72 | wait.Add(200)
73 | for i := 0; i < 100; i++ {
74 | go func(i int) {
75 | for j := 0; j <= 10; j++ {
76 | Tracef("1试试可以正常打印吗！这是第%d次 第%d次！", i, j)
77 | }
78 | wait.Done()
79 | }(i)
80 | }
81 | for i := 0; i < 100; i++ {
82 | go func(i int) {
83 | for j := 0; j <= 10; j++ {
84 | Tracef("2试试可以正常打印吗！这是第%d次 第%d次！", i, j)
85 | }
86 | wait.Done()
87 | }(i)
88 | }
89 | wait.Wait()
90 | }
91 | }
92 |
93 | func TestMapVSArray(t *testing.T) {
94 | t.Log("测试字典与切片，使用哪个性能更好")
95 | count := 1000000
96 |
97 | loggerMap := map[logType]*log.Logger{
98 | Leveltrace: log.New(os.Stdout, "", 0),
99 | Levelinfo: log.New(os.Stdout, "", 0),
100 | Leveldebug: log.New(os.Stdout, "", 0),
101 | Levelwarn: log.New(os.Stderr, "", 0),
102 | Levelerror: log.New(os.Stderr, "", 0),
103 | Levelpanic: log.New(os.Stderr, "", 0),
104 | Levelfatal: log.New(os.Stderr, "", 0),
105 | }
106 |
107 | loggerArr := []*log.Logger{
108 | Leveltrace: log.New(os.Stdout, "", 0),
109 | Levelinfo: log.New(os.Stdout, "", 0),
110 | Leveldebug: log.New(os.Stdout, "", 0),
111 | Levelwarn: log.New(os.Stderr, "", 0),
112 | Levelerror: log.New(os.Stderr, "", 0),
113 | Levelpanic: log.New(os.Stderr, "", 0),
114 | Levelfatal: log.New(os.Stderr, "", 0),
115 | }
116 |
117 | fmt.Println("---------------count:", count)
118 |
119 | st := time.Now()
120 | for i := 0; i < count; i++ {
121 | assert.NotNil(t, loggerMap[Leveltrace])
122 | assert.NotNil(t, loggerMap[Levelinfo])
123 | assert.NotNil(t, loggerMap[Leveldebug])
124 | assert.NotNil(t, loggerMap[Levelwarn])
125 | assert.NotNil(t, loggerMap[Levelerror])
126 | assert.NotNil(t, loggerMap[Levelpanic])
127 | assert.NotNil(t, loggerMap[Levelfatal])
128 | }
129 | fmt.Println("map:", time.Since(st))
130 |
131 | st = time.Now()
132 | for i := 0; i < count; i++ {
133 | assert.NotNil(t, loggerArr[Leveltrace])
134 | assert.NotNil(t, loggerArr[Levelinfo])
135 | assert.NotNil(t, loggerArr[Leveldebug])
136 | assert.NotNil(t, loggerArr[Levelwarn])
137 | assert.NotNil(t, loggerArr[Levelerror])
138 | assert.NotNil(t, loggerArr[Levelpanic])
139 | assert.NotNil(t, loggerArr[Levelfatal])
140 | }
141 | fmt.Println("array:", time.Since(st))
142 | }
143 |
144 | func TestColorCode(t *testing.T) {
145 | t.Log("测试颜色代码")
146 | {
147 | for i := 30; i <= 40; i++ {
148 | fmt.Printf("\033[%sm%s\033[0m\n", strconv.Itoa(i), "some thins you want to print out.")
149 | }
150 | }
151 | }
152 |
--------------------------------------------------------------------------------
/print_darwin.go:
--------------------------------------------------------------------------------
1 | package log
2 |
3 | import "fmt"
4 |
5 | //Trace级别的打印信息，输入要打印的内容，会自动换行
6 | func Trace(v ...interface{}) {
7 | trace := loggers[Leveltrace]
8 | s := fmt.Sprint(v...)
9 | message := joint(lTrace, s, colorGreen)
10 | trace.Println(message)
11 | }
12 |
13 | //Trace级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
14 | func Tracef(format string, v ...interface{}) {
15 | trace := loggers[Leveltrace]
16 | s := fmt.Sprintf(format, v...)
17 | message := joint(lTrace, s, colorGreen)
18 | trace.Println(message)
19 | }
20 |
21 | //Info级别的打印信息，输入要打印的内容，会自动换行
22 | func Info(v ...interface{}) {
23 | info := loggers[Levelinfo]
24 | s := fmt.Sprint(v...)
25 | message := joint(lInfo, s, colorBlue)
26 | info.Println(message)
27 | }
28 |
29 | //Infof级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
30 | func Infof(format string, v ...interface{}) {
31 | info := loggers[Levelinfo]
32 | s := fmt.Sprintf(format, v...)
33 | message := joint(lInfo, s, colorBlue)
34 | info.Println(message)
35 | }
36 |
37 | //Debug级别的打印信息，输入要打印的内容，会自动换行
38 | func Debug(v ...interface{}) {
39 | debug := loggers[Leveldebug]
40 | s := fmt.Sprint(v...)
41 | message := joint(lDebug, s, colorDarkblue)
42 | debug.Println(message)
43 | }
44 |
45 | //Debug级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
46 | func Debugf(format string, v ...interface{}) {
47 | debug := loggers[Leveldebug]
48 | s := fmt.Sprintf(format, v...)
49 | message := joint(lDebug, s, colorDarkblue)
50 | debug.Println(message)
51 | }
52 |
53 | //Warn级别的打印信息，输入要打印的内容，会自动换行
54 | func Warn(v ...interface{}) {
55 | warn := loggers[Levelwarn]
56 | s := fmt.Sprint(v...)
57 | message := joint(lWarn, s, colorYellow)
58 | warn.Println(message)
59 | }
60 |
61 | //Warn级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
62 | func Warnf(format string, v ...interface{}) {
63 | warn := loggers[Levelwarn]
64 | s := fmt.Sprintf(format, v...)
65 | message := joint(lWarn, s, colorYellow)
66 | warn.Println(message)
67 | }
68 |
69 | //Error级别的打印信息，输入要打印的内容，会自动换行
70 | func Error(v ...interface{}) {
71 | e := loggers[Levelerror]
72 | s := fmt.Sprint(v...)
73 | message := joint(lError, s, colorRed)
74 | e.Println(message)
75 | }
76 |
77 | //Errorf级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
78 | func Errorf(format string, v ...interface{}) {
79 | e := loggers[Levelerror]
80 | s := fmt.Sprintf(format, v...)
81 | message := joint(lError, s, colorRed)
82 | e.Println(message)
83 | }
84 |
85 | //Panic级别的打印信息，输入要打印的内容，会自动换行
86 | // 执行Panic，递归执行每层的defer后中断程序
87 | func Panic(v ...interface{}) {
88 | p := loggers[Levelpanic]
89 | s := fmt.Sprint(v...)
90 | message := joint(lPanic, s, colorRed)
91 | p.Panicln(message)
92 | }
93 |
94 | //Panicf级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容
95 | // 输出错误信息后，执行Panic()，递归执行每层的defer后中断程序
96 | func Panicf(format string, v ...interface{}) {
97 | p := loggers[Levelpanic]
98 | s := fmt.Sprintf(format, v...)
99 | message := joint(lPanic, s, colorRed)
100 | p.Panicln(message)
101 | }
102 |
103 | //Fatal级别的打印信息，输入要打印的内容，会自动换行
104 | // 输出错误信息后，直接执行os.exit(1)中断程序
105 | func Fatal(v ...interface{}) {
106 | falat := loggers[Levelfatal]
107 | s := fmt.Sprint(v...)
108 | message := joint(lFatal, s, colorPurple)
109 | falat.Fatalln(message)
110 | }
111 |
112 | //Fatal级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容
113 | // 输出错误信息后，直接执行os.exit(1)中断程序
114 | func Fatalf(format string, v ...interface{}) {
115 | falat := loggers[Levelfatal]
116 | s := fmt.Sprintf(format, v...)
117 | message := joint(lFatal, s, colorPurple)
118 | falat.Fatalln(message)
119 | }
120 |
121 | func (l mylog) Trace(v ...interface{}) {
122 | trace := l.loggers[Leveltrace]
123 | s := fmt.Sprint(v...)
124 | message := l.joint(lTrace, s, colorGreen)
125 | trace.Println(message)
126 | }
127 |
128 | func (l mylog) Tracef(format string, v ...interface{}) {
129 | trace := l.loggers[Leveltrace]
130 | s := fmt.Sprintf(format, v...)
131 | message := l.joint(lTrace, s, colorGreen)
132 | trace.Println(message)
133 | }
134 |
135 | func (l mylog) Info(v ...interface{}) {
136 | info := l.loggers[Levelinfo]
137 | s := fmt.Sprint(v...)
138 | message := l.joint(lInfo, s, colorBlue)
139 | info.Println(message)
140 | }
141 |
142 | func (l mylog) Infof(format string, v ...interface{}) {
143 | info := l.loggers[Levelinfo]
144 | s := fmt.Sprintf(format, v...)
145 | message := l.joint(lInfo, s, colorBlue)
146 | info.Println(message)
147 | }
148 |
149 | func (l mylog) Debug(v ...interface{}) {
150 | debug := l.loggers[Leveldebug]
151 | s := fmt.Sprint(v...)
152 | message := l.joint(lDebug, s, colorDarkblue)
153 | debug.Println(message)
154 | }
155 |
156 | func (l mylog) Debugf(format string, v ...interface{}) {
157 | debug := l.loggers[Leveldebug]
158 | s := fmt.Sprintf(format, v...)
159 | message := l.joint(lDebug, s, colorDarkblue)
160 | debug.Println(message)
161 | }
162 |
163 | func (l mylog) Warn(v ...interface{}) {
164 | warn := l.loggers[Levelwarn]
165 | s := fmt.Sprint(v...)
166 | message := l.joint(lWarn, s, colorYellow)
167 | warn.Println(message)
168 | }
169 |
170 | func (l mylog) Warnf(format string, v ...interface{}) {
171 | warn := l.loggers[Levelwarn]
172 | s := fmt.Sprintf(format, v...)
173 | message := l.joint(lWarn, s, colorYellow)
174 | warn.Println(message)
175 | }
176 |
177 | func (l mylog) Error(v ...interface{}) {
178 | e := l.loggers[Levelerror]
179 | s := fmt.Sprint(v...)
180 | message := l.joint(lError, s, colorRed)
181 | e.Println(message)
182 | }
183 |
184 | func (l mylog) Errorf(format string, v ...interface{}) {
185 | e := l.loggers[Levelerror]
186 | s := fmt.Sprintf(format, v...)
187 | message := l.joint(lError, s, colorRed)
188 | e.Println(message)
189 | }
190 |
191 | func (l mylog) Panic(v ...interface{}) {
192 | p := l.loggers[Levelpanic]
193 | s := fmt.Sprint(v...)
194 | message := l.joint(lPanic, s, colorRed)
195 | p.Panicln(message)
196 | }
197 |
198 | func (l mylog) Panicf(format string, v ...interface{}) {
199 | p := l.loggers[Levelpanic]
200 | s := fmt.Sprintf(format, v...)
201 | message := l.joint(lPanic, s, colorRed)
202 | p.Panicln(message)
203 | }
204 |
205 | func (l mylog) Fatal(v ...interface{}) {
206 | falat := l.loggers[Levelfatal]
207 | s := fmt.Sprint(v...)
208 | message := l.joint(lFatal, s, colorPurple)
209 | falat.Fatalln(message)
210 | }
211 |
212 | func (l mylog) Fatalf(format string, v ...interface{}) {
213 | falat := l.loggers[Levelfatal]
214 | s := fmt.Sprintf(format, v...)
215 | message := l.joint(lFatal, s, colorPurple)
216 | falat.Fatalln(message)
217 | }
218 |
--------------------------------------------------------------------------------
/print_linux.go:
--------------------------------------------------------------------------------
1 | package log
2 |
3 | import "fmt"
4 |
5 | //Trace级别的打印信息，输入要打印的内容，会自动换行
6 | func Trace(v ...interface{}) {
7 | trace := loggers[Leveltrace]
8 | s := fmt.Sprint(v...)
9 | message := joint(lTrace, s, colorGreen)
10 | trace.Println(message)
11 | }
12 |
13 | //Trace级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
14 | func Tracef(format string, v ...interface{}) {
15 | trace := loggers[Leveltrace]
16 | s := fmt.Sprintf(format, v...)
17 | message := joint(lTrace, s, colorGreen)
18 | trace.Println(message)
19 | }
20 |
21 | //Info级别的打印信息，输入要打印的内容，会自动换行
22 | func Info(v ...interface{}) {
23 | info := loggers[Levelinfo]
24 | s := fmt.Sprint(v...)
25 | message := joint(lInfo, s, colorBlue)
26 | info.Println(message)
27 | }
28 |
29 | //Infof级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
30 | func Infof(format string, v ...interface{}) {
31 | info := loggers[Levelinfo]
32 | s := fmt.Sprintf(format, v...)
33 | message := joint(lInfo, s, colorBlue)
34 | info.Println(message)
35 | }
36 |
37 | //Debug级别的打印信息，输入要打印的内容，会自动换行
38 | func Debug(v ...interface{}) {
39 | debug := loggers[Leveldebug]
40 | s := fmt.Sprint(v...)
41 | message := joint(lDebug, s, colorDarkblue)
42 | debug.Println(message)
43 | }
44 |
45 | //Debug级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
46 | func Debugf(format string, v ...interface{}) {
47 | debug := loggers[Leveldebug]
48 | s := fmt.Sprintf(format, v...)
49 | message := joint(lDebug, s, colorDarkblue)
50 | debug.Println(message)
51 | }
52 |
53 | //Warn级别的打印信息，输入要打印的内容，会自动换行
54 | func Warn(v ...interface{}) {
55 | warn := loggers[Levelwarn]
56 | s := fmt.Sprint(v...)
57 | message := joint(lWarn, s, colorYellow)
58 | warn.Println(message)
59 | }
60 |
61 | //Warn级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
62 | func Warnf(format string, v ...interface{}) {
63 | warn := loggers[Levelwarn]
64 | s := fmt.Sprintf(format, v...)
65 | message := joint(lWarn, s, colorYellow)
66 | warn.Println(message)
67 | }
68 |
69 | //Error级别的打印信息，输入要打印的内容，会自动换行
70 | func Error(v ...interface{}) {
71 | e := loggers[Levelerror]
72 | s := fmt.Sprint(v...)
73 | message := joint(lError, s, colorRed)
74 | e.Println(message)
75 | }
76 |
77 | //Errorf级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
78 | func Errorf(format string, v ...interface{}) {
79 | e := loggers[Levelerror]
80 | s := fmt.Sprintf(format, v...)
81 | message := joint(lError, s, colorRed)
82 | e.Println(message)
83 | }
84 |
85 | //Panic级别的打印信息，输入要打印的内容，会自动换行
86 | // 执行Panic，递归执行每层的defer后中断程序
87 | func Panic(v ...interface{}) {
88 | p := loggers[Levelpanic]
89 | s := fmt.Sprint(v...)
90 | message := joint(lPanic, s, colorRed)
91 | p.Panicln(message)
92 | }
93 |
94 | //Panicf级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容
95 | // 输出错误信息后，执行Panic()，递归执行每层的defer后中断程序
96 | func Panicf(format string, v ...interface{}) {
97 | p := loggers[Levelpanic]
98 | s := fmt.Sprintf(format, v...)
99 | message := joint(lPanic, s, colorRed)
100 | p.Panicln(message)
101 | }
102 |
103 | //Fatal级别的打印信息，输入要打印的内容，会自动换行
104 | // 输出错误信息后，直接执行os.exit(1)中断程序
105 | func Fatal(v ...interface{}) {
106 | falat := loggers[Levelfatal]
107 | s := fmt.Sprint(v...)
108 | message := joint(lFatal, s, colorPurple)
109 | falat.Fatalln(message)
110 | }
111 |
112 | //Fatal级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容
113 | // 输出错误信息后，直接执行os.exit(1)中断程序
114 | func Fatalf(format string, v ...interface{}) {
115 | falat := loggers[Levelfatal]
116 | s := fmt.Sprintf(format, v...)
117 | message := joint(lFatal, s, colorPurple)
118 | falat.Fatalln(message)
119 | }
120 |
121 | func (l mylog) Trace(v ...interface{}) {
122 | trace := l.loggers[Leveltrace]
123 | s := fmt.Sprint(v...)
124 | message := l.joint(lTrace, s, colorGreen)
125 | trace.Println(message)
126 | }
127 |
128 | func (l mylog) Tracef(format string, v ...interface{}) {
129 | trace := l.loggers[Leveltrace]
130 | s := fmt.Sprintf(format, v...)
131 | message := l.joint(lTrace, s, colorGreen)
132 | trace.Println(message)
133 | }
134 |
135 | func (l mylog) Info(v ...interface{}) {
136 | info := l.loggers[Levelinfo]
137 | s := fmt.Sprint(v...)
138 | message := l.joint(lInfo, s, colorBlue)
139 | info.Println(message)
140 | }
141 |
142 | func (l mylog) Infof(format string, v ...interface{}) {
143 | info := l.loggers[Levelinfo]
144 | s := fmt.Sprintf(format, v...)
145 | message := l.joint(lInfo, s, colorBlue)
146 | info.Println(message)
147 | }
148 |
149 | func (l mylog) Debug(v ...interface{}) {
150 | debug := l.loggers[Leveldebug]
151 | s := fmt.Sprint(v...)
152 | message := l.joint(lDebug, s, colorDarkblue)
153 | debug.Println(message)
154 | }
155 |
156 | func (l mylog) Debugf(format string, v ...interface{}) {
157 | debug := l.loggers[Leveldebug]
158 | s := fmt.Sprintf(format, v...)
159 | message := l.joint(lDebug, s, colorDarkblue)
160 | debug.Println(message)
161 | }
162 |
163 | func (l mylog) Warn(v ...interface{}) {
164 | warn := l.loggers[Levelwarn]
165 | s := fmt.Sprint(v...)
166 | message := l.joint(lWarn, s, colorYellow)
167 | warn.Println(message)
168 | }
169 |
170 | func (l mylog) Warnf(format string, v ...interface{}) {
171 | warn := l.loggers[Levelwarn]
172 | s := fmt.Sprintf(format, v...)
173 | message := l.joint(lWarn, s, colorYellow)
174 | warn.Println(message)
175 | }
176 |
177 | func (l mylog) Error(v ...interface{}) {
178 | e := l.loggers[Levelerror]
179 | s := fmt.Sprint(v...)
180 | message := l.joint(lError, s, colorRed)
181 | e.Println(message)
182 | }
183 |
184 | func (l mylog) Errorf(format string, v ...interface{}) {
185 | e := l.loggers[Levelerror]
186 | s := fmt.Sprintf(format, v...)
187 | message := l.joint(lError, s, colorRed)
188 | e.Println(message)
189 | }
190 |
191 | func (l mylog) Panic(v ...interface{}) {
192 | p := l.loggers[Levelpanic]
193 | s := fmt.Sprint(v...)
194 | message := l.joint(lPanic, s, colorRed)
195 | p.Panicln(message)
196 | }
197 |
198 | func (l mylog) Panicf(format string, v ...interface{}) {
199 | p := l.loggers[Levelpanic]
200 | s := fmt.Sprintf(format, v...)
201 | message := l.joint(lPanic, s, colorRed)
202 | p.Panicln(message)
203 | }
204 |
205 | func (l mylog) Fatal(v ...interface{}) {
206 | falat := l.loggers[Levelfatal]
207 | s := fmt.Sprint(v...)
208 | message := l.joint(lFatal, s, colorPurple)
209 | falat.Fatalln(message)
210 | }
211 |
212 | func (l mylog) Fatalf(format string, v ...interface{}) {
213 | falat := l.loggers[Levelfatal]
214 | s := fmt.Sprintf(format, v...)
215 | message := l.joint(lFatal, s, colorPurple)
216 | falat.Fatalln(message)
217 | }
218 |
--------------------------------------------------------------------------------
/print_windows.go:
--------------------------------------------------------------------------------
1 | package log
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | )
7 |
8 | //Trace级别的打印信息，输入要打印的内容，会自动换行
9 | func Trace(v ...interface{}) {
10 | trace := loggers[Leveltrace]
11 | s := fmt.Sprint(v...)
12 | var message string
13 | message = joint(lTrace, s, WinColorGreen)
14 | trace.Println(message)
15 | winKernelColse()
16 | }
17 |
18 | //Trace级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
19 | func Tracef(format string, v ...interface{}) {
20 | trace := loggers[Leveltrace]
21 | s := fmt.Sprintf(format, v...)
22 | var message string
23 | message = joint(lTrace, s, WinColorGreen)
24 | trace.Println(message)
25 | winKernelColse()
26 | }
27 |
28 | //Info级别的打印信息，输入要打印的内容，会自动换行
29 | func Info(v ...interface{}) {
30 | info := loggers[Levelinfo]
31 | s := fmt.Sprint(v...)
32 | var message string
33 | message = joint(lInfo, s, WinColorBlue)
34 | info.Println(message)
35 | winKernelColse()
36 | }
37 |
38 | //Infof级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
39 | func Infof(format string, v ...interface{}) {
40 | info := loggers[Levelinfo]
41 | s := fmt.Sprintf(format, v...)
42 | var message string
43 | message = joint(lInfo, s, WinColorBlue)
44 | info.Println(message)
45 | winKernelColse()
46 | }
47 |
48 | //Debug级别的打印信息，输入要打印的内容，会自动换行
49 | func Debug(v ...interface{}) {
50 | debug := loggers[Leveldebug]
51 | s := fmt.Sprint(v...)
52 | var message string
53 | message = joint(lDebug, s, WinColorDarkblue)
54 | debug.Println(message)
55 | winKernelColse()
56 | }
57 |
58 | //Debug级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
59 | func Debugf(format string, v ...interface{}) {
60 | debug := loggers[Leveldebug]
61 | s := fmt.Sprintf(format, v...)
62 | var message string
63 | message = joint(lDebug, s, WinColorDarkblue)
64 | debug.Println(message)
65 | winKernelColse()
66 | }
67 |
68 | //Warn级别的打印信息，输入要打印的内容，会自动换行
69 | func Warn(v ...interface{}) {
70 | warn := loggers[Levelwarn]
71 | s := fmt.Sprint(v...)
72 | var message string
73 | message = joint(lWarn, s, WinColorYellow)
74 | warn.Println(message)
75 | winKernelColse()
76 | }
77 |
78 | //Warn级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
79 | func Warnf(format string, v ...interface{}) {
80 | warn := loggers[Levelwarn]
81 | s := fmt.Sprintf(format, v...)
82 | var message string
83 | message = joint(lWarn, s, WinColorYellow)
84 | warn.Println(message)
85 | winKernelColse()
86 | }
87 |
88 | //Error级别的打印信息，输入要打印的内容，会自动换行
89 | func Error(v ...interface{}) {
90 | e := loggers[Levelerror]
91 | s := fmt.Sprint(v...)
92 | var message string
93 | message = joint(lError, s, WinColorRed)
94 | e.Println(message)
95 | winKernelColse()
96 | }
97 |
98 | //Errorf级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容，类似fmt.Printf
99 | func Errorf(format string, v ...interface{}) {
100 | e := loggers[Levelerror]
101 | s := fmt.Sprintf(format, v...)
102 | var message string
103 | message = joint(lError, s, WinColorRed)
104 | e.Println(message)
105 | winKernelColse()
106 | }
107 |
108 | //Panic级别的打印信息，输入要打印的内容，会自动换行
109 | // 执行Panic，递归执行每层的defer后中断程序
110 | func Panic(v ...interface{}) {
111 | p := loggers[Levelpanic]
112 | s := fmt.Sprint(v...)
113 | var message string
114 | message = joint(lPanic, s, WinColorPurple)
115 | defer winKernelColse()
116 | p.Panicln(message)
117 | }
118 |
119 | //Panicf级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容
120 | // 输出错误信息后，执行Panic()，递归执行每层的defer后中断程序
121 | func Panicf(format string, v ...interface{}) {
122 | p := loggers[Levelpanic]
123 | s := fmt.Sprintf(format, v...)
124 | var message string
125 | message = joint(lPanic, s, WinColorPurple)
126 | defer winKernelColse()
127 | p.Panicln(message)
128 | }
129 |
130 | //Fatal级别的打印信息，输入要打印的内容，会自动换行
131 | // 输出错误信息后，直接执行os.exit(1)中断程序
132 | func Fatal(v ...interface{}) {
133 | falat := loggers[Levelfatal]
134 | s := fmt.Sprint(v...)
135 | var message string
136 | message = joint(lFatal, s, WinColorPurple)
137 | falat.Println(message)
138 | winKernelColse()
139 | os.Exit(1)
140 | }
141 |
142 | //Fatal级别的打印信息，第一个参数输入格式,第二个参数输入要打印的内容
143 | // 输出错误信息后，直接执行os.exit(1)中断程序
144 | func Fatalf(format string, v ...interface{}) {
145 | falat := loggers[Levelfatal]
146 | s := fmt.Sprintf(format, v...)
147 | var message string
148 | message = joint(lFatal, s, WinColorPurple)
149 | falat.Println(message)
150 | winKernelColse()
151 | os.Exit(1)
152 | }
153 |
154 | func (l mylog) Trace(v ...interface{}) {
155 | trace := l.loggers[Leveltrace]
156 | s := fmt.Sprint(v...)
157 | var message string
158 | message = l.joint(lTrace, s, WinColorGreen)
159 | trace.Println(message)
160 | winKernelColse()
161 | }
162 |
163 | func (l mylog) Tracef(format string, v ...interface{}) {
164 | trace := l.loggers[Leveltrace]
165 | s := fmt.Sprint(v...)
166 | var message string
167 | message = l.joint(lTrace, s, WinColorGreen)
168 | defer winKernelColse()
169 | trace.Println(message)
170 | }
171 |
172 | func (l mylog) Info(v ...interface{}) {
173 | info := l.loggers[Levelinfo]
174 | s := fmt.Sprint(v...)
175 | var message string
176 | message = l.joint(lInfo, s, WinColorBlue)
177 | info.Println(message)
178 | winKernelColse()
179 | }
180 |
181 | func (l mylog) Infof(format string, v ...interface{}) {
182 | info := l.loggers[Levelinfo]
183 | s := fmt.Sprint(v...)
184 | var message string
185 | message = l.joint(lInfo, s, WinColorBlue)
186 | info.Println(message)
187 | winKernelColse()
188 | }
189 |
190 | func (l mylog) Debug(v ...interface{}) {
191 | debug := l.loggers[Leveldebug]
192 | s := fmt.Sprint(v...)
193 | var message string
194 | message = l.joint(lDebug, s, WinColorDarkblue)
195 | debug.Println(message)
196 | winKernelColse()
197 | }
198 |
199 | func (l mylog) Debugf(format string, v ...interface{}) {
200 | debug := l.loggers[Leveldebug]
201 | s := fmt.Sprint(v...)
202 | var message string
203 | message = l.joint(lDebug, s, WinColorDarkblue)
204 | debug.Println(message)
205 | winKernelColse()
206 | }
207 |
208 | func (l mylog) Warn(v ...interface{}) {
209 | warn := l.loggers[Levelwarn]
210 | s := fmt.Sprint(v...)
211 | var message string
212 | message = l.joint(lWarn, s, WinColorYellow)
213 | warn.Println(message)
214 | winKernelColse()
215 | }
216 |
217 | func (l mylog) Warnf(format string, v ...interface{}) {
218 | warn := l.loggers[Levelwarn]
219 | s := fmt.Sprint(v...)
220 | var message string
221 | message = l.joint(lWarn, s, WinColorYellow)
222 | warn.Println(message)
223 | winKernelColse()
224 | }
225 |
226 | func (l mylog) Error(v ...interface{}) {
227 | e := l.loggers[Levelerror]
228 | s := fmt.Sprint(v...)
229 | var message string
230 | message = l.joint(lError, s, WinColorRed)
231 | e.Println(message)
232 | winKernelColse()
233 | }
234 |
235 | func (l mylog) Errorf(format string, v ...interface{}) {
236 | e := l.loggers[Levelerror]
237 | s := fmt.Sprint(v...)
238 | var message string
239 | message = l.joint(lError, s, WinColorRed)
240 | e.Println(message)
241 | winKernelColse()
242 | }
243 |
244 | func (l mylog) Panic(v ...interface{}) {
245 | p := l.loggers[Levelpanic]
246 | s := fmt.Sprint(v...)
247 | var message string
248 | message = l.joint(lPanic, s, WinColorPurple)
249 | defer winKernelColse()
250 | p.Panicln(message)
251 | }
252 |
253 | func (l mylog) Panicf(format string, v ...interface{}) {
254 | p := l.loggers[Levelpanic]
255 | s := fmt.Sprint(v...)
256 | var message string
257 | message = l.joint(lPanic, s, WinColorPurple)
258 | defer winKernelColse()
259 | p.Panicln(message)
260 | }
261 |
262 | func (l mylog) Fatal(v ...interface{}) {
263 | falat := l.loggers[Levelfatal]
264 | s := fmt.Sprint(v...)
265 | var message string
266 | message = l.joint(lFatal, s, WinColorPurple)
267 | falat.Println(message)
268 | winKernelColse()
269 | os.Exit(1)
270 | }
271 |
272 | func (l mylog) Fatalf(format string, v ...interface{}) {
273 | falat := l.loggers[Levelfatal]
274 | s := fmt.Sprint(v...)
275 | var message string
276 | message = l.joint(lFatal, s, WinColorPurple)
277 | falat.Println(message)
278 | winKernelColse()
279 | os.Exit(1)
280 | }
281 |
--------------------------------------------------------------------------------