小编bla*_*een的帖子

我开始在我的 Go 项目中使用 zap 日志库。我想根据日志级别将不同的颜色打印到 tty 控制台。

我发现该zap/internal/color包可以显示不同颜色的字符串，但我想用不同的颜色更改日志级别。

我还想将日志写入一些具有不同日志级别的日志文件。

如何初始化和配置 zap 记录器？

我已将 Zap 与我的 go 应用程序集成，我们将日志打印在两个日志文件中，并且我还使用 Lumberjack 进行日志轮换。但我也尝试在控制台中显示日志，但在这种情况下没有运气。以下是我在 logger.go 中的代码

var (
    Logger *zap.Logger
    N2n    *zap.Logger
)

type WriteSyncer struct {
    io.Writer
}

func (ws WriteSyncer) Sync() error {
    return nil
}

func InitLogging(mode string) {
    var cfg zap.Config
    var logName = "abc.log"
    var slogName = "n2n.log"

    if mode == "production" {
        cfg = zap.NewProductionConfig()
        cfg.DisableCaller = true
    } else {
        cfg = zap.NewDevelopmentConfig()
        cfg.EncoderConfig.LevelKey = "level"
        cfg.EncoderConfig.NameKey = "name"
        cfg.EncoderConfig.MessageKey = "msg"
        cfg.EncoderConfig.CallerKey = "caller"
        cfg.EncoderConfig.StacktraceKey = "stacktrace"
    }

    cfg.Encoding …

我有一个从自定义配置（即config.Build()）生成的 Zap 记录器。我想通过调用来测试记录器，例如，logger.Info()在测试方法中并断言结果以查看它是否符合配置集。我怎样才能做到这一点？

代码示例：

func GetLogger() *zap.Logger{
 config := &zap.Config{
  Encoding: "json",
  Level: zap.NewAtomicLevelAt(zapcore.InfoLevel),
  OutputPaths: []string{"stdout"},
  ErrorOutputPaths: []string{"stdout"},
  EncoderConfig: zapcore.EncoderConfig{
   MessageKey: "@m",
   LevelKey:    "@l",
   EncodeLevel: zapcore.CapitalLevelEncoder,
   TimeKey:    "@t",
   EncodeTime: zapcore.EpochMillisTimeEncoder,
   CallerKey:     "@c",
   EncodeCaller:  zapcore.ShortCallerEncoder,
   StacktraceKey: "@x",
  },
 }
 return config.Build()
}

如果连接在 10 秒前关闭，如何取消进一步处理？

有c.Request.Context().Done()但找不到如何使用它的示例。

func main() {
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        time.Sleep(10 * time.Second) // or some db operation
        log.Print("Processing")
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })
    r.Run()
}

给出以下代码（从此处复制）：

     1  package main
     2  
     3  import (
     4      "fmt"
     5  
     6      "github.com/pkg/errors"
     7  
     8      "go.uber.org/zap"
     9  )
    10  
    11  func main() {
    12      logger, _ := zap.NewProduction()
    13      defer logger.Sync()
    14  
    15      sugar := logger.Sugar()
    16      result, err := caller1()
    17      if err != nil {
    18          sugar.Error(err)
    19          return
    20      }
    21      fmt.Println("Result: ", result)
    22  }
    23  
    24  func caller1() (int, error) {
    25      err := caller2()
    26      if err != nil {
    27          return …

例如，https : //github.com/golang/sys/blob/master/cpu/cpu_gccgo_x86.go#L5：

//go:build (386 || amd64 || amd64p32) && gccgo
// +build 386 amd64 amd64p32
// +build gccgo

package cpu

在我看来，作为构建标签，// +build ... 可以很好地工作。
为什么//go:build仍然明确指定？

顺便说一句，很难找到 的手册//go:build，但// +build很容易（https://pkg.go.dev/cmd/go#hdr-Build_constraints）

目前我正在开发一个使用 Serverless Framework 和 Go 的 API。

我正在使用 Serverless-offline 插件进行本地测试。

该 API 依赖于其他一些存储库（我也维护这些存储库），我使用该go.mod文件导入这些存储库。

然而，我很难完善我的开发人员工作流程。

目前，如果我想对此 API 所依赖的存储库进行更改，我必须更改项目go.mod以包含替换指令以进行测试，但随后我必须手动将其更改回以部署到生产环境。

基本上我正在寻找一种包含替换指令的方法，该指令仅在本地开发期间应用。其他人都是如何处理这个问题的？

额外问题：有什么方法可以在 docker 中离线运行 Serverless 吗？我发现在裸机上运行的无服务器离线会导致不同开发人员环境之间的不一致。

我有一个问题，我需要将两个非常大的结构（生成的 protobuf）相互比较，作为测试用例的一部分。这些结构体中有多个嵌套数组。下面是一个重现/演示该问题的简化示例。

package pkg

import (
    "github.com/stretchr/testify/assert"
    "reflect"
    "testing"
)

type structOne struct {
    Foo  string
    Offs []*structTwo
}

type structTwo struct {
    Identifier string
}

func Test_Compare(t *testing.T) {
    exp := &structOne{
        Foo: "bar",
        Offs: []*structTwo{
            {
                Identifier: "one",
            },
            {
                Identifier: "two",
            },
            {
                Identifier: "three",
            },
            {
                Identifier: "four",
            },
        },
    }

    act := &structOne{
        Foo: "bar",
        Offs: []*structTwo{
            {
                Identifier: "four",
            },
            {
                Identifier: "three",
            },
            {
                Identifier: "two",
            },
            {
                Identifier: "one",
            },
        },
    } …

在下面的代码中，我有一个包含文字值的标记类型。通过使用空接口，我可以创建一个令牌切片并附加具有不同类型的令牌。我认为使用泛型不可能完成相同的任务，因为我们无法推断令牌切片的类型。这个假设正确吗？

type Token struct {
    TokenType string
    Literal interface{}
}

func main(){
    tok1 := &Token{TokenType: "string", Literal: "foo"}
    tok2 := &Token{TokenType: "integer", Literal: 10}
    tokS := []*Token{tok1, tok2}
}

我将代码库更新为 Go 1.18。一切看起来都很棒，但在一些地方，我发现了以下问题。

defer func() {
    if e := recover() ; e!=nil {
        ...
    }
}()

编译失败并显示：

无法将“nil”转换为类型“any”

相同的代码在 Go 1.17 中运行良好。基于 Go 1.18 发行说明，是(Generics)any的内置类型别名interface{}

到底是怎么回事？