Em Go, interfaces são fundamentais para promover polimorfismo e abstração. Elas atuam como contratos que especificam um conjunto de métodos que um tipo deve implementar, permitindo que diferentes tipos sejam tratados de maneira uniforme e flexível.

Interfaces

Em Go, uma interface é um tipo que define um conjunto de métodos, sem implementá-los. Ela especifica apenas as assinaturas dos métodos que um tipo deve possuir para satisfazer a interface. Isso permite que diferentes tipos possam ser tratados de forma uniforme, desde que implementem os métodos definidos pela interface. Interfaces promovem polimorfismo e abstração, facilitando a criação de código flexível e reutilizável.

io.Writer

A interface io.Writer é uma das mais utilizadas em Go. Ela define o método Write, que recebe um slice de bytes ([]byte) e retorna um inteiro (int) e um erro (error). Diversos tipos implementam essa interface, incluindo os.File, bytes.Buffer e net.Conn. Isso permite que diferentes tipos de destinos de escrita sejam tratados de maneira uniforme e flexível.

// Writer é a interface que encapsula a operação básica de escrita.
type Writer interface {
    Write(p []byte) (n int, err error)
}

• Write: é o método que recebe um slice de bytes ([]byte) como argumento e retorna dois valores.
  • n: é o número de bytes escritos.
  • err: é um valor do tipo error que indica se ocorreu algum erro durante a escrita.

Qualquer tipo que implemente o método Write com a assinatura correta será considerarado um io.Writer.

Por que o io.Writer?

• Abstração: permite tratar diferentes tipos de destinos de escrita de forma uniforme.
• Flexibilidade: facilita a criação de métodos genéricos que aceitam qualquer tipo que implemente a interface io.Writer.
• Reutilização de código: utilizando o io.Writer pode ser reutilizado com diferentes tipos de destinos, como arquivos, sockets, buffers, etc.
• Teste: permite criar mocks e stubs para testar código de forma isolada.

Exemplo

package main

import (
  "fmt"
  "os"
  "io"
)

func main() {
  var w io.Writer = os.Stdout // w é do tipo io.Writer

  n, err := w.Write([]byte("Hello, World!"))
  if err != nil {
    fmt.Println("Erro:", err)
  }

  fmt.Printf("\bBytes escritos: %b", n)
}

/tmp ➜ go run example_io_writer.go
Hello, World!
Bytes escritos: 1101

Conclusão

A interface io.Writer é uma das interfaces mais comuns em Go. Ela é usada para abstrair a operação de escrita de dados, permitindo que diferentes tipos de destinos de escrita sejam tratados de forma uniforme. Isso facilita a reutilização de código, a criação de métodos genéricos e a escrita de testes. Além disso, a interface io.Writer promove polimorfismo, permitindo que diferentes tipos que implementam a interface sejam usados de maneira intercambiável. Ela é amplamente implementada em vários pacotes padrão da linguagem Go, como os, bytes, net, entre outros, demonstrando sua versatilidade e importância no ecossistema Go.

Referências

https://pkg.go.dev/io#Writer
https://pkg.go.dev/os@go1.23.3#File.Write
https://pkg.go.dev/log/slog/internal/buffer#Buffer.Write
https://pkg.go.dev/net@go1.23.3#Conn