Dans Go, les interfaces sont fondamentales pour promouvoir le polymorphisme et l'abstraction. Ils agissent comme des contrats qui spécifient un ensemble de méthodes qu'un type doit mettre en œuvre, permettant à différents types d'être traités uniformément et de manière flexible.

Interfaces

Dans Go, une interface est un type qui définit un ensemble de méthodes sans les implémenter. Il spécifie uniquement les signatures des méthodes qu'un type doit avoir pour satisfaire l'interface. Cela permet à différents types d'être traités uniformément tant qu'ils implémentent les méthodes définies par l'interface. Les interfaces favorisent le polymorphisme et l'abstraction, facilitant la création d'un code flexible et réutilisable.

io.writer

L'interface io.writer est l'une des plus utilisées dans GO. Plusieurs types implémentent cette interface, notamment OS.File, Bytes.Buffer et Net.Conn. Cela permet à différents types de destinations d'écriture d'être traitées uniformément et flexibles.

// L'écrivain est l'interface qui résume l'opération d'écriture de base. Type d'interface d'écrivain { Écrire (p [] octet) (n int, err error) }

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

N: c'est le nombre d'octets écrits.
• ERR: Il s'agit d'une valeur de type d'erreur qui indique si des erreurs se produisent pendant l'écriture.
  • Tout type qui implémente la méthode d'écriture avec l'abonnement correct sera considéré comme un io.writer.
  Pourquoi The.Writer io.writer?

Abstraction

: vous permet de traiter différents types de destinations d'écriture.

flexibilité

: facilite la création de méthodes génériques qui acceptent tout type qui implémente l'interface io.writer.
• Réutilisation du code : L'utilisation de io.writer peut être réutilisée avec différents types de destinations, tels que des fichiers, des prises, des bufffers, etc.
• test : vous permet de créer des simulations et des talons pour tester le code isolé.
• Exemple package principal importer ( "FMT" "toi" "Io" ) Func main () { var w io.writer = os.stoutout // w est du type io.writer N, err: = w.write ([] octet ("Hello, world!")))) Si err! fmt.println ("erreur:", err) } fmt.printf ("\ bbytes écrits:% b", n) }
• / tmp ➜ allez exécuter example_io_writer.go Bonjour le monde! Écrits d'octets: 1101 Conclusion

L'interface io.writer est l'une des interfaces les plus courantes de GO. Cela facilite la réutilisation du code, la création de méthodes génériques et l'écriture de tests. De plus, l'interface IO.Writer favorise le polymorphisme, permettant à différents types qui implémentent l'interface sont utilisées de manière interchangeable. Il est largement mis en œuvre dans plusieurs packages de langage GO standard, tels que les octets, le net, entre autres, démontrant sa polyvalence et son importance dans l'écosystème Go.

Références

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)
}

https://pkg.go.dev/[email protected]#file.wital* https://pkg.go.dev/log/slog/internal/buffer#buffer.write*&&&] https://pkg.go.dev/[email protected]#Conn*&&&]

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