我正在学习 golang，并且被困在一个令人尴尬的简单概念上。也许是我的 OO 习惯影响了我的理解，但我似乎无法让这个简单的例子起作用:

package main

import (
    "fmt"
)

type datafield struct {
    name  string
    value string
}

func (d datafield) NewField(name, value string) *datafield {
    retval := new(datafield)
    retval.name = name
    retval.value = value
    return retval
}

func main() {
    field := datafield.NewField("name", "value")
    if field == nil {
        fmt.Println("Error: Did not create a datafield")
    } else {
        fmt.Println("Success!")
    }
}

错误是:

prog.go:20:29: not enough arguments in call to method expression datafield.NewField
    have (string, string)
    want (datafield, string, string)

获取 NewField(string,string) 以创建数据字段的正确方法是什么？

最佳答案

Go 不完全是面向对象的语言并且提倡简单性，这就是为什么之前的答案都集中在修复您的代码上。不过，如果您真的需要在 Go 中实现此设计模式，请进一步阅读。

The factory method pattern is a creational pattern that uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created. This is done by creating objects by calling a factory method. (wikipedia)

这是 Svetlin 在 Go 中的另一个定义和一个非常好的例子 拉尔切夫:

The Factory Method pattern is used to define a runtime interface for creating an object. It’s called a factory because it creates various types of objects without necessarily knowing what kind of object it creates or how to create it. (Desing Patterns in Golang: Factory Method)

我稍微扩展了您的示例以展示使用工厂方法的好处，因为如果您正在处理一个结构(OO 世界中的一个对象)，则根本不需要使用工厂。 https://goplay.space/#SOXPmM86GgF

package main

import (
    "fmt"
)

type dataField interface {
    Print()
}
type dataField1 struct {
    name  string
    value string
}

func (df *dataField1) Print() {
    fmt.Println("dataField1 ->", df.name, ":", df.value)
}

type dataField2 struct {
    name  string
    value string
}

func (df *dataField2) Print() {
    fmt.Println("dataField2 ->", df.name, ":", df.value)
}

type dataFieldFactory interface {
    Create(name, value string) dataField
}

type dataField1Factory struct{}

func (factory *dataField1Factory) Create(name, value string) dataField {
    return &dataField1{
        name:  name,
        value: value,
    }
}

type dataField2Factory struct{}

func (factory *dataField2Factory) Create(name, value string) dataField {
    return &dataField2{
        name:  name,
        value: value,
    }
}

type Document struct {
    dataFieldFactories []dataFieldFactory
    allValues          [][]string
}

func (doc *Document) Print() {
    for i, factory := range doc.dataFieldFactories {
        field := factory.Create(doc.allValues[i][0], doc.allValues[i][1])
        field.Print()
    }
}

func main() {
    doc := &Document{
        dataFieldFactories: []dataFieldFactory{
            &dataField1Factory{},
            &dataField2Factory{},
        },
        allValues: [][]string{{"name1", "value1"}, {"name2", "value2"}},
    }
    doc.Print()
}

程序只是打印这个

dataField1 -> name1 : value1
dataField2 -> name2 : value2

但是，如果您查看 main func，您不会发现具体类型 dataField1 和 dataField2 的任何提及或初始化。 所有的复杂性都隐藏在 dataFieldFactories 的背后。 dataField1Factory 和dataField2Factory 都实现了Create 接口(interface)并返回dataField 接口(interface)，这两个具体类型 也执行。因此，您可以为每个具体类型调用 Print()。

Document.Print() 同时使用 Create 和 Print 接口(interface)进行打印 在不了解这些字段的实际创建或打印方式的情况下排除所有字段。我们通过向文档结构(对象)提供工厂方法列表(dataField1Factory{} 和 dataField2Factory{})和相应的字符串值来实现这一点。

对不起，我举了一个有点人为的例子，但我希望，你会明白基本的想法。 如您所见，Go 允许您实现您熟悉的设计模式，也许与您在纯 OO 语言中习惯的方式不同。

关于Golang 工厂方法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/49712313/