Go: What is the difference between interface and struct?

Interface — defines a set of method signatures (behavior). Struct — defines named fields (data).

Interfaces in Go are satisfied implicitly — any type that implements all the methods automatically satisfies the interface, no implements keyword needed. This decouples consumers from concrete types and enables polymorphism.

1type Writer interface {
2    Write([]byte) (int, error)
3}
4
5// *os.File satisfies Writer without declaring it
6func save(w Writer, data []byte) {
7    w.Write(data)
8}

Structs hold the actual data. You attach methods to structs (pointer or value receiver) to define behavior. A struct can implement multiple interfaces simultaneously.

1type File struct {
2    name string
3    size int
4}
5
6func (f *File) Write(p []byte) (int, error) {
7    // implementation
8    return len(p), nil
9}
10
11// File now satisfies both Writer and fmt.Stringer
12func (f *File) String() string { return f.name }

When to use:

• Interface — when you need abstraction, testability (mocking), or polymorphic behavior.
• Struct — when you need to store data and define concrete types.

Common mistakes:

• Defining interfaces too wide — prefer small, focused interfaces (Go proverb: "The bigger the interface, the weaker the abstraction").
• Returning concrete types in public APIs when an interface would allow better extensibility.
• Using interface{} (now any) excessively instead of defining proper typed interfaces.
• Forgetting that interface values are nil only when both the type and value are nil — a nil pointer wrapped in an interface is NOT nil.