Golang中如何启用和禁用包中的日志记录

Golang中如何启用和禁用包中的日志记录 大家好， 我是Go语言新手，我想实现以下功能： 修改这个包，使得用户可以启用或禁用包中的日志记录。当启用日志记录时，该包应在处理之后、返回结果之前，将答案记录到一个文件中。

type Divider struct{
log bool
}
func NewDivider(islog bool) *Divider{
return &Divider{log: islog}
}
func (d *Divider) Divide(firstValue, secondValue float64) (float64) {
result = firstValue+secondValue
if d.log} {
log.Println(result)}
{
return result
}

更多关于Golang中如何启用和禁用包中的日志记录的实战教程也可以访问 https://www.itying.com/category-94-b0.html

9 回复

谢谢，但你能给我一个例子吗？

更多关于Golang中如何启用和禁用包中的日志记录的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


谢谢

非常感谢。

很好

Go Playground - The Go Programming Language

package whatever

var loggingEnabled bool=true

func EnableLogging() {
  loggingEnabled=true
}
func DisableLogging() {
  loggingEnabled=false
}
func AnyWhateverAPIFunction() {
  if loggingEnabled {
    writeLog()
  }
}

你可以从用户那里获取一个关于是否将任何应用程序日志写入文件的输入（以布尔值形式），然后将其存储在一个全局变量中，并在每次写入日志时检查是否应该将日志写入文件。你也可以编写一个自定义的日志函数，以避免每次都编写该代码。

你还可以使用配置文件来让用户定义这样的条件。

log 包允许定义一个无操作的日志记录器

logger = log.New(io.Discard, "", log. LstdFlags)

然后你可以将这个日志记录器传递给您的 API。

这样一来，您就不需要每次都检查日志记录功能是否已启用。

func MakeLogger(enabled bool) *log.Logger {
    writer := io.Discard
    if enabled {
         writer := io.StdErr
    }
    return log.New(writer, "", log.LstdFlags)
}

func main() {
    var logEnabled bool
    // 从标志位或环境变量读取启用状态
    logger := MakeLogger(logEnabled)

    yourApi(logger)
}

func yourApi(logger log.logger) {
     logger.Print("Hello")
}

在Go语言中，可以通过配置日志记录器来实现包中日志的启用和禁用。以下是修改后的代码示例：

package main

import (
    "log"
    "os"
)

type Divider struct {
    logEnabled bool
    logger     *log.Logger
    logFile    *os.File
}

func NewDivider(isLogEnabled bool, logFilePath string) (*Divider, error) {
    d := &Divider{logEnabled: isLogEnabled}
    
    if isLogEnabled && logFilePath != "" {
        file, err := os.OpenFile(logFilePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
        if err != nil {
            return nil, err
        }
        d.logFile = file
        d.logger = log.New(file, "DIVIDER: ", log.Ldate|log.Ltime|log.Lshortfile)
    }
    
    return d, nil
}

func (d *Divider) Divide(firstValue, secondValue float64) float64 {
    result := firstValue / secondValue
    
    if d.logEnabled && d.logger != nil {
        d.logger.Printf("Divide %.2f / %.2f = %.2f", firstValue, secondValue, result)
    }
    
    return result
}

func (d *Divider) Close() {
    if d.logFile != nil {
        d.logFile.Close()
    }
}

// 使用示例
func main() {
    // 启用日志记录
    dividerWithLog, err := NewDivider(true, "division.log")
    if err != nil {
        log.Fatal(err)
    }
    defer dividerWithLog.Close()
    
    result := dividerWithLog.Divide(10, 2)
    _ = result
    
    // 禁用日志记录
    dividerWithoutLog, _ := NewDivider(false, "")
    result2 := dividerWithoutLog.Divide(20, 4)
    _ = result2
}

另一种更灵活的方式是使用接口：

package main

import (
    "io"
    "log"
    "os"
)

type Logger interface {
    Log(format string, args ...interface{})
}

type FileLogger struct {
    logger *log.Logger
}

func NewFileLogger(w io.Writer) *FileLogger {
    return &FileLogger{
        logger: log.New(w, "DIVIDER: ", log.Ldate|log.Ltime|log.Lshortfile),
    }
}

func (f *FileLogger) Log(format string, args ...interface{}) {
    f.logger.Printf(format, args...)
}

type NullLogger struct{}

func (n *NullLogger) Log(format string, args ...interface{}) {
    // 什么都不做，实现静默日志
}

type Divider struct {
    logger Logger
}

func NewDivider(logger Logger) *Divider {
    return &Divider{logger: logger}
}

func (d *Divider) Divide(firstValue, secondValue float64) float64 {
    result := firstValue / secondValue
    
    if d.logger != nil {
        d.logger.Log("Divide %.2f / %.2f = %.2f", firstValue, secondValue, result)
    }
    
    return result
}

// 使用示例
func main() {
    // 启用日志记录到文件
    file, _ := os.OpenFile("division.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    defer file.Close()
    
    fileLogger := NewFileLogger(file)
    dividerWithLog := NewDivider(fileLogger)
    result := dividerWithLog.Divide(10, 2)
    _ = result
    
    // 禁用日志记录
    nullLogger := &NullLogger{}
    dividerWithoutLog := NewDivider(nullLogger)
    result2 := dividerWithoutLog.Divide(20, 4)
    _ = result2
}

对于简单的开关控制，可以使用标准库的log包：

package main

import (
    "io/ioutil"
    "log"
    "os"
)

type Divider struct {
    logEnabled bool
}

func NewDivider(isLogEnabled bool) *Divider {
    return &Divider{logEnabled: isLogEnabled}
}

func (d *Divider) Divide(firstValue, secondValue float64) float64 {
    result := firstValue / secondValue
    
    if d.logEnabled {
        // 启用日志
        log.SetOutput(os.Stdout)
        log.Printf("Divide %.2f / %.2f = %.2f", firstValue, secondValue, result)
    } else {
        // 禁用日志
        log.SetOutput(ioutil.Discard)
    }
    
    return result
}

// 使用示例
func main() {
    // 启用日志记录
    dividerWithLog := NewDivider(true)
    result := dividerWithLog.Divide(10, 2)
    _ = result
    
    // 禁用日志记录
    dividerWithoutLog := NewDivider(false)
    result2 := dividerWithoutLog.Divide(20, 4)
    _ = result2
}

这些示例展示了如何在Go包中实现可配置的日志记录功能，用户可以根据需要选择启用或禁用日志，并将日志输出到指定文件。

回到顶部