log

log包提供对日志记录的功能

网站查询：
log使用方法
本地查询方法：

  1. # 如果官网访问不了或时间太长可以查看本地的标准库 与官网没什么区别。只不过官网更直观而已
  2. ligz@DESKTOP-911J8B9 MINGW64 /e
  3. $ go doc log
  4. package log // import "log"
  6. Package log implements a simple logging package. It defines a type, Logger,
  7. with methods for formatting output. It also has a predefined 'standard'
  8. Logger accessible through helper functions Print[f|ln], Fatal[f|ln], and
  9. Panic[f|ln], which are easier to use than creating a Logger manually. That
  10. logger writes to standard error and prints the date and time of each logged
  11. message. Every log message is output on a separate line: if the message
  12. being printed does not end in a newline, the logger will add one. The Fatal
  13. functions call os.Exit(1) after writing the log message. The Panic functions
  14. call panic after writing the log message.
  16. const Ldate = 1 << iota ...
  17. func Fatal(v ...interface{})
  18. func Fatalf(format string, v ...interface{})
  19. func Fatalln(v ...interface{})
  20. func Flags() int
  21. func Output(calldepth int, s string) error
  22. func Panic(v ...interface{})
  23. func Panicf(format string, v ...interface{})
  24. func Panicln(v ...interface{})
  25. func Prefix() string
  26. func Print(v ...interface{})
  27. func Printf(format string, v ...interface{})
  28. func Println(v ...interface{})
  29. func SetFlags(flag int)
  30. func SetOutput(w io.Writer)
  31. func SetPrefix(prefix string)
  32. func Writer() io.Writer
  33. type Logger struct{ ... }
  34.     func Default() *Logger
  35.     func New(out io.Writer, prefix string, flag int) *Logger

常用的方法：

  • Fatal：记录日志并退出程序
  • Fatalf： 按照指定格式记录日志并退出程序
  • Fatalln：记录日志并退出程序，并在日志中写入换行
  • Panic： 记录日志并调用panic
  • Panicf： 按照指定格式记录日志并调用panic
  • Panicln： 记录日志并调用panic，并在日志中写入换行
  • Print： 记录日志
  • Printf： 按照指定格式记录日志
  • Println： 记录日志，并在日志中换行
  • Output： 记录日志栈
  • SetPrefix: 设置日志前缀
  • SetFlags： 设置日志开头
  • Flags： 获取日志开头

  • SetOutput：设置日志输出流

    常用结构体

  • Logger

常用函数

  • New： 用与创建logger对象

常用方法

  • 见{常用的方法} 上面👍

    实操

    learnLog.go

    ```go package learnLog

import ( “bufio” “log” “os” )

func LearnLog(){ log.Println(“Line 1”)

  1. log.SetPrefix("log:")
  2. log.Println("Line two")
  4. log.Println(log.Flags())
  5. log.SetFlags(log.Flags()| log.Lshortfile)
  6. log.Println("Line 3")
  8. file, _ := os.OpenFile("logone.log", os.O_APPEND| os.O_CREATE, 0755)
  9. defer func() {
  10.     _ = file.Close()
  11. }()
  12. writer := bufio.NewWriter(file)
  13. defer func() {
  14.     writer.Flush()
  15. }()
  16. log.SetOutput(writer)
  17. log.Println("Line 4")
  18. log.Println("Line five")
  19. log.Println("line six")
  21. log.Output(1, "line seven")
  22. log.Output(2, "Line 8")
  24. // logger
  25. f2, _ := os.OpenFile("l2.log", os.O_APPEND| os.O_CREATE, os.ModePerm)
  26. defer func() {
  27.     _ = f2.Close()
  28. }()
  29. w2 := bufio.NewWriter(f2)
  30. defer func() {
  31.     _ = w2.Flush()
  32. }()
  33. logger :=  log.New(w2, "log2:", log.LstdFlags| log.Lshortfile)
  35. logger.Println("Line 1")
  36. logger.Println("Line 2")
  37. logger.Println("Line3")

}

  1. <a name="lED7z"></a>
  2. ### learnLog_test.go
  3. ```go
  4. package learnLog
  6. import "testing"
  8. func TestLearnLog(t *testing.T) {
  9.     LearnLog()
  10. }

结果

  1. package learnLog
  3. import "testing"
  5. func TestLearnLog(t *testing.T) {
  6.     LearnLog()
  7. }
  9. # vim logone.log
  10. log:2021/08/29 20:39:58 learnLog.go:28: Line 4
  11. log:2021/08/29 20:39:58 learnLog.go:29: Line five
  12. log:2021/08/29 20:39:58 learnLog.go:30: line six
  13. log:2021/08/29 20:39:58 learnLog.go:32: line seven
  14. log:2021/08/29 20:39:58 learnLog_test.go:6: Line 8