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中，我还想通过接口和实现来做同样的事情。

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中接口函数的逻辑吗？如何使它们与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")
}

由于所有类型都可以具有方法，因此所有类型（包括函数类型）都可以实现接口。因此，如果您确实愿意，可以让A依赖于接口并定义用于即时提供实现的函数类型：

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")
}

Answer 2

我可以覆盖文件B.go中接口函数的逻辑吗？

否，Go（和其他语言）的接口没有任何逻辑或实现。

要在Go中实现一个接口，我们只需要在该接口中实现所有方法即可。

A和B类型如何使用不同的逻辑实现相同的接口

type Doer interface {
    Do(string)
}

type A struct {
    name string
}
func (a *A) Do(name string){
    a.name = name;
    // do one thing
}

type B struct {
    name string
}
func (b *B) Do(name string){
    b.name = name;
    // do another thing
}

从不同的包实现接口（从其他模块回调）

2 个答案: