duan2477
duan2477
2018-09-05 22:18
浏览 47
已采纳

在Golang中使用接收器返回函数

I am new to Golang. And I am trying to use a decorator which returns a function with a receiver. How can I do that?

type myStruct struct {
    s string
}

func myFunc(s string) {
    fmt.Println(s)
}

// Here I want to return a function with a receiver
func (*myStruct) myDecorator(fn func(string)) (*myStruct)func(string){
    return (ms *myStruct)func(s string) {
        fn(ms+s)
    }
}

func main() {
    ms := myStruct{"Hello"}
    // Some func is function with receiver as myStruct pointer
    someFunc := myDecorator(myFunc)
    // This is expected to print "Hello world"
    ms.someFunc(" world")
}

图片转代码服务由CSDN问答提供 功能建议

我是Golang的新手。 我正在尝试使用装饰器,该装饰器返回带有接收器的函数。 我该怎么做?

  type myStruct struct {
s string 
} 
 
func myFunc(s string){
 fmt.Println(s)
  } 
 
 //这里我想返回一个带有接收者的函数
func(* myStruct)myDecorator(fn func(string))(* myStruct)func(string){
 return(ms * myStruct)func(  s string){
 fn(ms + s)
} 
} 
 
func main(){
 ms:= myStruct {“ Hello”} 
 // //一些函数以接收者作为myStruct指针起作用 
 someFunc:= myDecorator(myFunc)
 //预期会打印“ Hello world” 
 ms.someFunc(“ world”)
} 
   
 
  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

1条回答 默认 最新

  • dptn69182
    dptn69182 2018-09-05 23:52
    已采纳

    As noted in my comment, you cannot modify the method set of a type in the return from a function call, so directly extending the behavior of the myStruct struct is not possible in your "decorator" function as written.

    I am actually using this decorator to wrap fmt.Sprintf, Sprintln, Sprint method to get Logger.Debugln, Logger.Debugf, Logger.Warning, ... methods, where Logger is a self-defined struct, since these functions shares almost the same behavior.

    You also will not be able to pass around the fmt.Sprintf, fmt.Sprintln and fmt.Sprint functions in a generic way, as they share different signatures:

    func Print(a ...interface{}) (n int, err error)
    func Printf(format string, a ...interface{}) (n int, err error)
    func Println(a ...interface{}) (n int, err error)
    

    so you will need to wrap these methods separately.

    It isn't entirely clear to me how you are seeking to wrap those methods to produce your Logger type.

    If you require each of those methods at the top level of your logger, they will need to be explicitly declared in your logging package or on your Logger type's interface. You cannot dynamically bind each level function at runtime, despite their obvious similarities; go is a statically-typed language so your types must be declared upfront.

    Defining the types explicitly will be the clearest solution, which is also in keeping with a key go proverb: "Clear is better than clever."

    If necessary, you can declare each method as a simple wrapper of an internal method on your type which actually performs the printing logic, keeping repetition to a minimum.

    Here's a quick example I threw together to show the logic for some Debug, Debugf and Debugln endpoints. You can see the core logic is handled by a generic set of methods on the Logger type, and you can imagine how endpoints for other log levels could be trivially implemented.

    If repetition is really a problem, you could trivially write a code generator to automatically generate the log-level specific methods, calling on the core functionality explicitly declared in the various print functions. Remember you can declare receivers for a type in multiple source files in the same package, allowing some methods to be generated in some source files while others are implemented explicitly elsewhere.

    package main
    
    import (
        "fmt"
        "io"
        "os"
    )
    
    type Level string
    
    const (
        Debug Level = "DEBUG"
        Error       = "ERROR"
    
    // etc.
    )
    
    type Logger struct {
        writer       io.Writer
        prependLevel bool
    }
    
    func (l *Logger) print(level Level, msg string) {
        var s string
        if l.prependLevel {
            s = string(level) + ": "
        }
        s += msg
        fmt.Fprint(l.writer, s)
    }
    
    func (l *Logger) printf(level Level, format string, a ...interface{}) {
        l.print(level, fmt.Sprintf(format, a...))
    }
    
    func (l *Logger) println(level Level, msg string) {
        l.printf(level, "%s
    ", msg)
    }
    
    func (l *Logger) Debug(msg string) {
        l.print(Debug, msg)
    }
    
    func (l *Logger) Debugf(format string, a ...interface{}) {
        l.printf(Debug, format, a...)
    }
    
    func (l *Logger) Debugln(msg string) {
        l.println(Debug, msg)
    }
    
    func main() {
        logger := Logger{os.Stderr, true}
        logger.Debugln("A plain message with a new line")
        logger.Debugf(
            ("The most customizable log entry with some parameters: " +
                "%s %v
    "),
            "myStr", false,
        )
        logger.Debug("A bare print statement")
    }
    

    Playground link.


    Third-party packages

    In case you haven't yet done so, there are many third-party logging packages in Go which I would recommend considering, or at least assessing their interfaces to determine how others have approached similar tasks.

    Logrus is a Go logger with levels, for example. You can see in their source files how they explicitly declare their interface for each function at each log level, while using a more comprehensive version of the method above to reduce repetition in the core logging implementation: Interface Formatter implementations

    点赞 评论

相关推荐