Eine Schnittstelle in GO ist ein Typ, der eine Reihe von Methodensignaturen definiert, und jeder Typ, der diese Methoden implementiert, erfüllt die Schnittstelle automatisch ohne explizite Deklaration. 1. Definieren Sie eine Schnittstelle mit Methodensignaturen wie Sprecher mit Speak () String. 2. Implementieren Sie die Schnittstelle durch Bereitstellung der Methoden für jede Art, z. B. Hunde- und Katzenstrukturen mit einer Speak () -Methode. 3.. Verwenden Sie die Schnittstellenwerte austauschbar, wie mit einem Scheibenlautsprecher sowohl Hund als auch Katze h?lt. 4. Verwenden Sie eine beliebige Art (oder Schnittstelle {}), um einen Typ zu akzeptieren, jedoch Typenbehauptungen anwenden oder Schalter anwenden, um den zugrunde liegenden Typ bei Bedarf abzurufen. 5. Befolgen Sie die Best Practices: Halten Sie Schnittstellen klein, lassen Sie sie auf natürliche Weise auftauchen, verwenden Sie alle sparsamen, bevorzugen Wertsch?pfungsempf?nger und nutzen Sie Standard-Library-Muster wie IO.Writer. Schnittstellen in Go f?rdern Polymorphismus, Flexibilit?t und sauberes Design, indem sie sich eher auf das Verhalten als auf die Implementierung konzentrieren, wodurch Code komponierbar, wiederverwendbar und überprüfbar macht.

In Go sind Schnittstellen eine starke M?glichkeit, Polymorphismus und Dekuple -Code zu erreichen. Sie erm?glichen es Ihnen, das Verhalten zu definieren, ohne die Implementierung anzugeben und Ihren Code flexibler und wiederverwendbarer zu machen.

Was ist eine Schnittstelle in Go?

Eine Schnittstelle ist ein Typ, der einen Satz von Methodensignaturen angibt. Jeder Typ, der alle Methoden in der Schnittstelle implementiert, erfüllt sie automatisch - es besteht keine Notwendigkeit, sie explizit zu deklarieren. Dies ist als implizite Implementierung bekannt.

So definieren Sie eine grundlegende Schnittstelle:

 Typlautsprecherschnittstelle {
    Speak () String
}

Diese Speaker erfordert einen implementierenden Typ, um eine Speak() -Methode zu haben, die eine Zeichenfolge zurückgibt.

So implementieren Sie eine Schnittstelle

Jeder Typ (wie eine Struktur) kann die Schnittstelle durch Bereitstellung der erforderlichen Methoden implementieren.

 Geben Sie Hundestrukturen ein {
    Name Zeichenfolge
}

func (d hund) speak () string {
    Rückkehr "Woof! Ich bin" d.name
}

Typ Cat struct {
    Name Zeichenfolge
}

func (c cat) speak () string {
    Rückkehr "Meow! Ich bin" C.Name
}

Jetzt erfüllen sowohl Dog als auch Cat die Speaker , weil sie eine Speak() string -Methode haben.

Sie k?nnen sie austauschbar verwenden:

 func main () {
    Tiere: = [] Sprecher {Hund {Name: "Buddy"}, Cat {Name: "Whiskers"}}

    Für _, Tier: = Bereiche Tiere {
        fmt.println (Animal.speak ())
    }
}

Ausgabe:

 Schuss! Ich bin Kumpel
Miau! Ich bin Schnurrhaare

HINWEIS: Die Zuordnung zum Speaker funktioniert, da die GO zum Kompilierungszeit überprüft werden, ob die Typen die erforderlichen Methoden implementieren.

Leere Schnittstelle: interface{} (Pre-Go 1.18)

Vor Go 1.18 wurde die leere Schnittstelle als interface{} geschrieben und konnte einen Wert haben, da sie keine Methoden enth?lt:

 var x interface {} = "Hallo"
var y Schnittstelle {} = 42

Ab Go 1.18 k?nnen Sie any als lesbareren Alias verwenden:

 var x irgendwelche = "Hallo"

Sowohl interface{} als auch any dasselbe bedeutet.

Nützlich für Funktionen, die jeden Typ akzeptieren:

 Func Print (v Any) {
    fmt.println (v)
}

Aber denken Sie daran: Sie ben?tigen wahrscheinlich Typen oder Typen, um den zugrunde liegenden Wert zurückzugewinnen.

Geben Sie Behauptungen ein und geben Sie Schalter ein

Da Schnittstellen Betontypen ausblenden, müssen Sie m?glicherweise den ursprünglichen Typ extrahieren.

Geben Sie die Behauptung ein :

 Wenn Hund, OK: = Tier. (Hund); OK {
    fmt.println ("Found a Hund:", Hund.name)
}

Schalter eingeben :

 Switch v: = Tier. (Typ) {
Fall Hund:
    fmt.println ("Es ist ein Hund:", V.Name)
Case Cat:
    fmt.println ("Es ist eine Katze:", V.Name)
Standard:
    fmt.println ("unbekanntes Tier")
}

Dies ist besonders hilfreich, wenn Sie unterschiedliche Verhaltensweisen basierend auf dem tats?chlichen Typ behandeln.

Best Practices und Tipps

• Halten Sie Schnittstellen klein : Gehen Sie die kleinen, fokussierten Schnittstellen (wie io.Reader , io.Writer ).
• Lassen Sie Schnittstellen auf natürliche Weise auftauchen : Zwingen Sie keine Typen, um gro?e Schnittstellen zu befriedigen. Definieren Sie bei Bedarf Schnittstellen, nicht im Voraus.
• Verwenden Sie die Schnittstelle {} (oder irgendein) sparsam : Sie verliert Type -Sicherheit. Generika (eingeführt in Go 1.18) sind oft eine bessere Wahl.
• Bevorzugen Sie Wertsch?pfer, es sei denn, eine Mutation ist erforderlich : Konsistente Empf?ngertypen helfen, versehentliche Schnittstellenfehlanpassungen zu vermeiden.

Beispiel: Verwenden von Standardf?den im standardm??igen Bibliotheksstil

Die Standardbibliothek von Go verwendet dieses Muster stark. Zum Beispiel:

 Geben Sie die Autor -Schnittstelle {ein
    Schreiben ([] byte) (n int, erral error)
}

Sie k?nnen eine Funktion schreiben, die mit jedem Schriftsteller funktioniert:

 Func Greet (W io.Writer, Name String) {
    fmt.fprintf (W, "Hallo, %s! \ n", Name)
}

Jetzt funktioniert es mit Dateien, Netzwerkverbindungen, Puffern usw., solange sie Write implementieren.

Grunds?tzlich geht es mit Schnittstellen in GO darüber, was ein Typ kann , nicht wie es ist. Sie definieren sie durch das Verhalten, das sie ben?tigen, und erfüllen sie automatisch, indem sie die Methoden implementieren. Es h?lt die Dinge einfach, komponierbar und überprüfbar.

Das obige ist der detaillierte Inhalt vonWie definiere und benutze ich Schnittstellen in Golang?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!