Wie ich aufhörte, mir Sorgen zu machen, und lernte, Go-Schnittstellen zu lieben

Hallo, liebe Go-Neulinge (oder sollte ich Gophers in Ausbildung sagen?)! ?
Schnittstellen schienen eines dieser mysteriösen, magischen Dinge zu sein, über die alle redeten, die aber niemand wirklich auf eine sinnvolle Weise erklärte. „Es ist wie Polymorphismus, aber einfacher“, sagten sie. „Es ist wie ein Vertrag“, behaupteten sie. Aber jedes Mal, wenn ich versuchte, eines zu implementieren, schaute mich mein Code an: „Was machst du überhaupt, Mensch?“ ?

Aber das war damals. Mittlerweile verstehen sich Interfaces und ich viel besser und ich bin hier, um Ihnen zu helfen, meine anfängliche Verwirrung zu vermeiden. Wenn Sie sich also über Go-Schnittstellen den Kopf zerbrochen haben, holen Sie sich eine Tasse Kaffee (oder Tee) und lassen Sie uns die Sache Schritt für Schritt aufschlüsseln – ohne die Kopfschmerzen. ?
Was genau ist eine Schnittstelle?

Beginnen wir ganz oben. In Go ist eine Schnittstelle im Grunde eine Möglichkeit, Verhalten zu definieren, ohne sich jedoch in den Details seiner Funktionsweise zu verlieren. Stellen Sie sich vor, Sie sind der Chef einer Fabrik und es ist Ihnen egal, wie die Maschine funktioniert. Sie kümmern sich nur darum, dass das Produkt hergestellt werden kann. So sind Go-Schnittstellen: Sie definieren, was passieren muss, aber nicht, wie es gemacht werden soll.

Stellen wir uns zum Beispiel vor, wir arbeiten mit Tieren (ja, Go arbeitet mit Tieren, bleiben Sie hier bei mir). Sie wissen, dass jedes Tier ein Geräusch macht, aber es ist Ihnen eigentlich egal, wie das passiert. Hunde bellen, Katzen miauen und Enten … nun ja, sie quaken. Sie können eine Schnittstelle wie folgt definieren:

type Animal interface {
    Sound() string
}

Was ist das? Nur ein Vertrag, der besagt: „Hey, jeder Typ, der Animal genannt werden möchte, muss eine Sound()-Methode haben.“ Das ist es! Keine seltsame Zauberei erforderlich.

Zeigen Sie mir den Code! ???

Nehmen wir ein supereinfaches Beispiel und sehen, wie es in Aktion funktioniert. Wir werden einige Tiere erschaffen und sie zum Sprechen bringen.

package main

import "fmt"

// The Animal interface
type Animal interface {
    Sound() string
}

// Define a Dog
type Dog struct{}

func (d Dog) Sound() string {
    return "Woof!"
}

// Define a Cat
type Cat struct{}

func (c Cat) Sound() string {
    return "Meow!"
}

func main() {
    // Our Animal variable can hold any type that satisfies the interface
    var myPet Animal

    // myPet is now a Dog
    myPet = Dog{}
    fmt.Println(myPet.Sound())  // Outputs: Woof!

    // myPet is now a Cat
    myPet = Cat{}
    fmt.Println(myPet.Sound())  // Outputs: Meow!
}

Was passiert hier?

1. Wir definieren eine Animal-Schnittstelle, die eine Methode hat: Sound() ?.
2. Dann erstellen wir zwei Typen, Hund und Katze, und geben ihnen ihre einzigartigen Sound()-Methoden.
3. In der main()-Funktion erstellen wir eine Variable myPet, die alles enthalten kann, was die Animal-Schnittstelle erfüllt.
4. Zuerst weisen wir einen Hund zu und bumm! Unser Hund bellt: „Wuff!“ ?
5. Dann weisen wir eine Katze zu und wissen Sie was? Es miaut: „Miau!“ ?

Hier kommt die Magie der Go-Schnittstellen erst richtig zur Geltung ??:
Solange ein Typ über die erforderliche Methode verfügt, erfüllt er die Schnittstelle. Es ist nicht nötig, ausdrücklich zu sagen: „Hund implementiert Tier“ – Go ist schlau genug, es selbst herauszufinden! ??

Warum sollten Sie sich für Schnittstellen interessieren?

Lassen Sie mich mit Ihnen auf Augenhöhe sein. Zuerst dachte ich: „Warum sollte ich mich überhaupt darum kümmern? Ich kann meine Methoden einfach direkt schreiben!“ Aber glauben Sie mir, Sie werden Schnittstellen eher früher als später verstehen wollen, insbesondere wenn Ihre Codebasis zu wachsen beginnt.

Hier ist der Grund:

1. Flexibilität: Schnittstellen machen Ihren Code flexibler. Sie können einen Typ gegen einen anderen austauschen, solange dieser die Schnittstelle erfüllt. Es ist, als würde man jemanden aufgrund seiner Fähigkeiten und nicht aufgrund seiner Berufsbezeichnung einstellen.

2. Polymorphismus: Sie können verschiedene Typen einheitlich behandeln, wenn sie dieselbe Schnittstelle implementieren. Das macht Schnittstellen so leistungsstark – es ist, als hätte man eine Universalfernbedienung, die mit jedem Fernseher funktioniert.

3. Sauberer Code: Schnittstellen ermöglichen es Ihnen, saubereren, modulareren Code zu schreiben. Sie definieren Verhaltensweisen und lassen die Typen ihre eigene Implementierung übernehmen.

Mehrere Methoden, kein Problem!

Lassen Sie es uns noch einen Schritt weiter bringen. Angenommen, Sie erstellen ein System zum Arbeiten mit Formen und möchten sowohl die Fläche als auch den Umfang für verschiedene Formen wie Kreise und Rechtecke berechnen. Betreten Sie die Multi-Methoden-Schnittstelle!

type Animal interface {
    Sound() string
}

Die leere Schnittstelle (interface{})

Oh, du dachtest, wir wären fertig???? Nein! Gehen wir etwas tiefer mit der leeren Schnittstelle interface{} um, mit der Go sagen kann: „Ich kann jeden Typ speichern.“ Es ist wie eine Box, in der alles frei ist – Strings, Zahlen, Strukturen – was auch immer.

package main

import "fmt"

// The Animal interface
type Animal interface {
    Sound() string
}

// Define a Dog
type Dog struct{}

func (d Dog) Sound() string {
    return "Woof!"
}

// Define a Cat
type Cat struct{}

func (c Cat) Sound() string {
    return "Meow!"
}

func main() {
    // Our Animal variable can hold any type that satisfies the interface
    var myPet Animal

    // myPet is now a Dog
    myPet = Dog{}
    fmt.Println(myPet.Sound())  // Outputs: Woof!

    // myPet is now a Cat
    myPet = Cat{}
    fmt.Println(myPet.Sound())  // Outputs: Meow!
}

Die leere Schnittstelle wird häufig in Situationen verwendet, in denen Sie nicht im Voraus wissen, mit welchem ​​Typ Sie es zu tun haben (denken Sie an APIs oder Bibliotheken). Es ist wie Gos Version eines Platzhalters.

Umarmen Sie die Schnittstelle

Das Erlernen von Go-Schnittstellen kann sich zunächst wie das Navigieren durch ein Labyrinth anfühlen, aber sobald Sie die Grundlagen verstanden haben, eröffnet es eine völlig neue Welt flexiblen, wiederverwendbaren und sauberen Codes. Haben Sie also keine Angst einzutauchen!

Beginnen Sie einfach, spielen Sie mit kleinen Beispielen und lassen Sie die Magie der Benutzeroberfläche von Go auf sich wirken. Schon bald werden Sie Code schreiben, der so sauber und flexibel ist wie ein Yogalehrer auf einer Technologiekonferenz.

Viel Spaß beim Codieren, liebe Gopher-Kollegen! Mögen Ihre Schnittstellen einfach und Ihre Strukturen stets umsetzbar sein. ?✌️

Das obige ist der detaillierte Inhalt vonWie ich aufhörte, mir Sorgen zu machen, und lernte, Go-Schnittstellen zu lieben. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!