node.js - 从不同的包实现接口(interface)(从其他模块回调)

Question

在NodeJS中，我可以在一个地方声明一个回调并在一个地方使用它，以避免破坏项目的结构。

A.js

module.exports = class A(){
    constructor(name, callback){
        this.name = name;
        this.callback = callback;
    }
    doSomeThingWithName(name){
        this.name = name;
        if(this.callback){
            this.callback();
        }
    }
}

B.js

const A = require(./A);
newA = new A("KimKim", ()=> console.log("Say Oyeah!"));

在 Go 中，我也想用接口(interface)和实现做同样的事情。

A.go

type canDoSomething interface {
    DoSomething()
}
type AStruct struct {
    name string
    callback canDoSomething
}
func (a *AStruct) DoSomeThingWithName(name string){
    a.name = name;
    a.callback.DoSomething()
}

B.go

import (A);
newA = A{}
newA.DoSomeThingWithName("KimKim");

我可以覆盖文件 B.go 中接口(interface)函数的逻辑吗？我该怎么做才能让它们等同于 NodeJS 的风格？

我试试

import (A);
newA = A{}

// I want
//newA.callback.DoSomething = func(){}...
// or
// func (a *AStruct) DoSomething(){}...
// :/
newA.DoSomeThingWithName("KimKim");

Answer 1

函数是 Go 中的一等值，就像它们在 JavaScript 中一样。您在这里不需要界面(除非您没有说明其他目标):

type A struct {
    name string
    callback func()
}

func (a *A) DoSomeThingWithName(name string){
    a.name = name;
    a.callback()
}

func main() {
    a := &A{
        callback: func() { /* ... */ },
    }

    a.DoSomeThingWithName("KimKim")
}

由于所有类型都可以有方法，所以所有类型(包括函数类型)都可以实现接口(interface)。所以如果你真的想要，你可以让 A 依赖于一个接口(interface)并定义一个函数类型来提供即时实现:

type Doer interface {
    Do()
}

// DoerFunc is a function type that turns any func() into a Doer.
type DoerFunc func()

// Do implements Doer
func (f DoerFunc) Do() { f() }

type A struct {
    name     string
    callback Doer
}

func (a *A) DoSomeThingWithName(name string) {
    a.name = name
    a.callback.Do()
}

func main() {
    a := &A{
        callback: DoerFunc(func() { /* ... */ }),
    }

    a.DoSomeThingWithName("KimKim")
}