How Can I Efficiently Add a Common Method to Different Go Structs Sharing a Field?

Adding a Method to Different Structs with a Common Field in Go

In your application, you encounter a requirement to implement a Save() method for two models, ModelA and ModelB. Despite their differences, they share a common field, Guid. Usually, a base struct is created to hold common fields and embedded into the individual models. However, this approach poses an obstacle for ORMs like beego/orm.

Implementing the Save() Method with an Interface

One effective solution is to define an interface, Savable, and implement it within both ModelA and ModelB. This enables you to use the interface type to call the Save() method, regardless of the specific model being used. Here's an example:

type Savable interface {
    Save()
}

func (a ModelA) Save() {
    // Save implementation for ModelA
}

func (b ModelB) Save() {
    // Save implementation for ModelB
}

// Example usage
var i Savable
i = SomeMethodThatRetunsMyModel()
i.Save()

Embedding a Common Struct

If embedded types are preferred, an alternative approach can be taken. Create a common struct, ModelC, to hold the Guid field. Then, embed ModelC into ModelA and ModelB. Define the Save() method within ModelC, thereby providing the shared functionality across both models.

type ModelC struct {
    Guid string `orm:"pk"`
}

func (c ModelC) Save() error {
    // Common Save implementation
    return nil
}

type ModelA struct {
    ModelC
    FiledA string
}

type ModelB struct {
    ModelC
    FiledB string
}

It's important to note that this embedding approach will not include any fields in the ORM's insert statement that are not defined in ModelC. Thus, direct references to ModelC methods may be necessary if non-common fields need to be explicitly manipulated.

The above is the detailed content of How Can I Efficiently Add a Common Method to Different Go Structs Sharing a Field?. For more information, please follow other related articles on the PHP Chinese website!