Go: interfaces

  • Go
  • Gabriele Romanato

Interfaces are one of the most powerful tools in the Go programming language. Because of their flexibility and ability to provide effective abstraction, interfaces allow programmers to write code that is modular, extensible, and easy to maintain.

In Go, an interface is a collection of methods, defined by a signature but with no implementation. A structure or custom type can implement an interface simply by implementing all the methods defined in it. This "duck typing" approach allows you to write code that depends on the interface, rather than a specific type, increasing the flexibility and reusability of the code.

A simple example would be an interface definition for a "Greeter" object: 

type Greeter interface {
	Greet() string
}

Any type that implements the Greet() method will be considered a Greeter . For example, we can have a Person type that implements the Greeter interface: 

type Person struct {
	Name string
}
func (p Person) Greet() string {
	return fmt.Sprintf("Hello, my name is %s", p.Name)
}

Now we can create a new Person instance and use it as a Greeter : 

p := Person{Name: "John"}
GreetSomeone(p)

The GreetSomeone function can be defined as follows: 

func GreetSomeone(g Greeter) {
	fmt.Println(g.Greet())
}

This way, the code that calls GreetSomeone doesnt have to worry about the specific type of the object passed as an argument. This means that we can easily extend our code by adding new types that implement the Greeter interface without having to modify the GreetSomeone function.

Interfaces in Go also allow you to combine multiple interfaces into a single interface. This is useful when you want to create a new interface that combines the functionality of multiple existing interfaces. For example: 


	type Readable interface {
		Read() string
	}
	
	type Writeable interface {
		Write(string)
	}
	
	type ReadWrite interface {
		Readable
		Writeable
	}

In this example, the ReadWrite interface combines the functionality of the Readable and Writeable interfaces, allowing you to pass an object that implements both interfaces to a function that requires a ReadWrite interface.

The interfaces in Go provide a powerful tool for writing modular, extensible, and easy-to-maintain code. They allow you to write code that depends on the interface, rather than a specific type, improving the flexibility of your code. Also, by combining multiple interfaces into a single interface, you can create new interfaces that combine the functionality of existing interfaces. With interfaces, Go promotes interface-oriented software design, enabling programmers to create cleaner, more robust code.

Back to top