1. Verstehen von Namenskonventionen

Namenskonventionen sind entscheidend für die Entwicklung von Software, da sie einen Rahmen für die benennung Ihrer Variablen, Funktionen und anderer Identifikatoren in einer konsistenten und beschreibenden Weise bieten. In Go (oft als Golang bezeichnet) macht die Einhaltung etablierter Namenskonventionen Ihren Code nicht nur einfacher lesbar und wartbar, sondern ermöglicht es anderen (und Ihrem zukünftigen Ich), Ihren Codebestand mit weniger Reibung zu verstehen und daran mitzuwirken.

1.1. Warum Namensgebung wichtig ist

In jeder Programmiersprache kann die Art und Weise, wie Sie Ihre Identifikatoren benennen, das Verständnis und die Wartbarkeit Ihres Codes erheblich beeinflussen. In Go, das auf Einfachheit und Klarheit Wert legt, ist eine ordnungsgemäße Namensgebung noch wichtiger. Namen, die den Zweck einer Variablen oder Funktion deutlich vermitteln, reduzieren die Notwendigkeit zusätzlicher Kommentare und machen den Code selbstdokumentierend. Dies ist entscheidend für die langfristige Wartung eines Codebestands und für die nahtlose Zusammenarbeit im Team.

1.2. Allgemeine Regeln zur Namensgebung

Die Namensregeln in Go sind einfach, aber kraftvoll:

  • Verwenden Sie kurze, prägnante Namen: Go ermutigt die Verwendung kurzer Namen, insbesondere für Variablen mit kleinem Gültigkeitsbereich. Zum Beispiel könnte i für einen Schleifenindex verwendet werden, aber wenn mehr Klarheit erforderlich ist, könnten index oder counter verwendet werden.

  • CamelCase für mehrwortige Namen: Verwenden Sie bei einem Namen, der aus mehreren Wörtern besteht, die CamelCase-Schreibweise. Exportierte Namen (die außerhalb des Pakets zugänglich sein sollen) sollten mit einem Großbuchstaben beginnen (MyFunction), während interne Namen mit einem Kleinbuchstaben beginnen sollten (myFunction).

  • Verwenden Sie aussagekräftige Namen: Namen sollten ausreichend beschreibend sein, um ihren Zweck oder ihre Verwendung zu vermitteln, ohne dabei übermäßig ausführlich zu sein. Beispielsweise ist CalculateNetIncome vorzuziehen gegenüber CNI.

  • Vermeiden Sie Unterstriche: Im Gegensatz zu einigen Sprachen vermeidet Go die Verwendung von Unterstrichen in Namen. Anstelle von record_count würde man recordCount verwenden.

  • Akronyme sollten konsistent sein: Bei der Verwendung von Akronymen in Namen müssen diese in konsistenter Schreibweise verwendet werden. Bei exportierten Namen wird alles in Großbuchstaben geschrieben (HTTPServer), und bei internen Namen ist alles in Kleinbuchstaben (httpServer) gängige Praxis.

  • Paketnamen sollten einfach sein: Paketnamen in Go werden einfach und in Kleinbuchstaben gehalten, ohne Unterstriche oder gemischte Groß- und Kleinschreibung. Sie sollten ein einzelnes Wort sein, das den Zweck des Pakets klar repräsentiert (net, os, json).

  • Variablennamen basierend auf dem Typ: Bei Variablen, die Instanzen von Strukturen darstellen, ist es üblich, den Namen der Struktur in Kleinbuchstaben als Variablennamen zu verwenden (var user User).

Hier ist ein Beispiel für Go-Code mit Kommentaren, die die Namensentscheidungen erklären:

package main

import "fmt"

type User struct {
    FirstName string
    LastName  string
    Age       int
}

func main() {
    var currentUser User // Verwendung des struct-Namens in Kleinbuchstaben als Variablenname.
    currentUser.FirstName = "John"
    currentUser.LastName = "Doe"
    currentUser.Age = 30

    fmt.Println(formatUserDetails(currentUser))
}

// formatUserDetails nimmt eine User-Struktur als Eingabe entgegen und gibt einen formatierten String zurück.
// Der Funktionsname beginnt mit einem Kleinbuchstaben, da er nicht exportiert ist (privat).
func formatUserDetails(u User) string {
    return fmt.Sprintf("Name: %s %s, Age: %d", u.FirstName, u.LastName, u.Age)
}

Die Einhaltung dieser Namenskonventionen verbessert die Qualität Ihres Go-Codes erheblich, indem sie ihn lesbarer und wartbarer macht.

2. Bezeichner in Go

Wenn Sie Ihre Reise mit Go beginnen, ist es wichtig, die Rolle der Bezeichner zu verstehen. Bezeichner sind Namen, die Sie verschiedenen Elementen Ihres Codes zuweisen, wie z.B. Variablen, Funktionen und Konstanten. Die Auswahl aussagekräftiger und konsistenter Namen trägt dazu bei, Ihren Code besser lesbar und wartbar zu machen.

2.1. Variablennamenskonventionen

In Go müssen Variablennamen mit einem Buchstaben oder einem Unterstrich beginnen, gefolgt von einer beliebigen Kombination aus Buchstaben, Ziffern oder Unterstrichen. Es wird jedoch nicht empfohlen, mit einem Unterstrich zu beginnen, da er oft für spezielle Zwecke reserviert ist.

Best Practices:

  • Verwenden Sie kurze, aussagekräftige Namen.
  • Beginnen Sie für den Paketbereich mit einem Kleinbuchstaben.
  • Verwenden Sie CamelCase für mehrwortige Namen (z.B. totalAmount).
  • Für exportierte Variablen (außerhalb des Pakets zugänglich) beginnen Sie mit einem Großbuchstaben.

Beispiel:

var userName string // nicht exportierte Variable
var UserAge int     // exportierte Variable

Kommentare im Code erläutern den Unterschied zwischen exportierten und nicht exportierten Variablen.

2.2. Namenskonventionen für Funktionen

Funktionen in Go werden nach ähnlichen Regeln wie Variablen benannt. Der Name sollte den Zweck der Funktion widerspiegeln, und ihr Gültigkeitsbereich bestimmt die Groß- und Kleinschreibung des ersten Buchstabens.

Best Practices:

  • Verwenden Sie aussagekräftige Namen, die den Zweck der Funktion widerspiegeln.
  • Beginnen Sie mit einem Kleinbuchstaben für interne Funktionen.
  • Verwenden Sie PascalCase (Beginn mit einem Großbuchstaben) für exportierte Funktionen.
  • Halten Sie die Funktionsnamen knapp, aber aussagekräftig.

Beispiel:

func calculateTotal(preis int, menge int) int { // Interne Funktion
    return preis * menge
}

func CalculateDiscount(gesamtPreis int) float64 { // Exportierte Funktion
    return gesamtPreis * 0.1
}

Die Kommentare erklären die Zugänglichkeit der Funktion basierend auf ihrer Groß- und Kleinschreibung und geben einen kurzen Einblick in ihren Zweck.

2.3. Namenskonventionen für Konstanten

Konstanten sind unveränderliche Werte, die, sobald definiert, nicht geändert werden können. In Go werden Konstanten mit dem Schlüsselwort const deklariert und können Zeichen, Zeichenfolgen, boolesche oder numerische Werte sein.

Best Practices:

  • Verwenden Sie ausschließlich Großbuchstaben mit Unterstrichen zur Trennung (z.B. MAX_LIMIT).
  • Verwenden Sie für aufgezählte Konstanten den iota-Enumerator.
  • Exportierte Konstanten sollten mit einem Großbuchstaben beginnen.

Beispiel:

const MAX_RETRY_COUNT int = 3 // Exportierte Konstante

type ByteSize float64
const (
    _           = iota // Ignorieren des ersten Werts durch Zuweisung an ein leeres Identifikator
    KB ByteSize = 1 << (10 * iota)
    MB
    GB
    TB
)

Das Beispiel zeigt, wie einfache Konstanten und eine Gruppe von zugehörigen Konstanten unter Verwendung von iota für Bytegrößen definiert werden.

3. Namenskonventionen für Typen

Dieses Kapitel konzentriert sich auf die Standards für die Benennung unterschiedlicher Typen wie Strukturen und Schnittstellen.

3.1. Richtlinien zur Benennung von Strukturen

Übersicht: Strukturen in Go repräsentieren zusammengesetzte Datentypen, die Variablen gruppieren. Bei der Benennung von Strukturen sollten aussagekräftige Namen in PascalCase verwendet werden, die mit einem Großbuchstaben beginnen.

  • Gute Praxis: Benennen Sie Strukturen mit Substantiven oder Nominalphrasen, die klar beschreiben, was sie darstellen. Zum Beispiel:
// Gut
type Mitarbeiter struct {
    ID        int
    Vorname   string
    Nachname  string
    Position  string
}
  • Vermeiden: Die Verwendung von mehrdeutigen oder generischen Namen, die den Zweck der Struktur nicht vermitteln.
// Vermeiden
type Daten struct {
    ID        int
    Vorname   string
    Nachname  string
    Position  string
}

3.2. Richtlinien zur Benennung von Schnittstellen

Übersicht: Schnittstellen in Go spezifizieren Methodensets und werden mit aussagekräftigen Namen benannt, die mit einem 'er'-Suffix enden, wenn es sinnvoll ist.

  • Gute Praxis: Benennen Sie Schnittstellen nach dem Verhalten, das sie abstrahieren. Typischerweise sollte, wenn eine Schnittstelle nur eine Methode enthält, der Name die Aktion dieser Methode plus ein '-er'-Suffix widerspiegeln.
// Gut
type Leser interface {
    Read(p []byte) (n int, err error)
}
  • Benennung von Verhaltenssammlungen: Wenn eine Schnittstelle eine Sammlung von Verhaltensweisen repräsentiert, wählen Sie einen Namen, der ihren Zweck genau widerspiegelt, ohne das 'er'-Suffix.
// Beispiel für eine Verhaltenssammlung
type Dateisystem interface {
    ReadFile(pfad string) ([]byte, error)
    WriteFile(pfad string, daten []byte) error
}

4. Groß- und Kleinschreibung und exportierte Bezeichner

4.1. Exportierte vs. nicht exportierte Namen

In Go wird die Sichtbarkeit eines Bezeichners außerhalb seines eigenen Pakets durch die Groß- und Kleinschreibung seines ersten Buchstabens bestimmt. Ein Bezeichner, der mit einem Großbuchstaben beginnt, ist "exportiert", was bedeutet, dass er von anderen Paketen aus aufgerufen werden kann. Dies entspricht dem öffentlichen Bereich in anderen Programmiersprachen. Andererseits sind Bezeichner, die mit Kleinbuchstaben beginnen, "nicht exportiert" oder privat und können nur innerhalb ihres eigenen Pakets verwendet werden.

Beispiel:

package geometrie

// Exportierter Bezeichner
type Rechteck struct {
    Länge, Breite float64
}

// Nicht exportierter Bezeichner
type punkt struct {
    x, y float64
}

In diesem Beispiel ist Rechteck ein exportierter Typ, weil er mit einem Großbuchstaben beginnt und von anderen Paketen genutzt werden kann, die das Paket geometrie importieren. Demgegenüber ist der Typ punkt nicht exportiert und kann nur innerhalb des Pakets geometrie verwendet werden.

4.2. Best Practices for Exported Identifiers

Bei der Benennung von exportierten Identifiern ist es unerlässlich, einige bewährte Praktiken zu befolgen, um sicherzustellen, dass Ihr Code von anderen gelesen und verstanden werden kann:

  • Klarheit vor Kürze: Wählen Sie klare und beschreibende Namen anstelle von kurzen und kryptischen. Zum Beispiel ist BerechneFläche gegenüber BerechneFl bevorzugt.
  • Konsistenz: Achten Sie darauf, dass Benennungskonventionen im gesamten Code eingehalten werden. Wenn Sie ähnliche Entitäten mit bestimmten Mustern benennen, halten Sie sich daran.
  • Redundanz vermeiden: Wiederholen Sie keine Paketnamen in den Identifiernamen. Verwenden Sie beispielsweise geometrie.Rechteck anstelle von geometrie.GeometrieRechteck.
  • Kontext berücksichtigen: Namen von Identifiern sollten im Kontext, in dem sie verwendet werden, Sinn ergeben. Vermeiden Sie Namen, die irreführend oder mehrdeutig sein könnten.
  • Dokumentationskommentare: Verwenden Sie Kommentare, um exportierte Identifizierer zu dokumentieren und zu erklären, was sie tun und wie sie verwendet werden sollten.

Beispiel:

package geometrie

// BerechneFläche gibt die Fläche eines Rechtecks zurück.
func (r Rechteck) BerechneFläche() float64 {
    return r.Länge * r.Breite
}

In diesem Beispiel handelt es sich bei BerechneFläche um eine exportierte Funktion mit einem klaren, beschreibenden Namen und einem Dokumentationskommentar, der ihren Zweck erklärt.

5. Benennungskonventionen in der Praxis

In diesem Kapitel werden wir uns mit der Anwendung von Go-Benennungskonventionen in realen Szenarien befassen. Das Verständnis und die Einhaltung dieser Konventionen sind entscheidend, da dies sicherstellt, dass Ihr Code idiomatisch, leicht lesbar und wartbar ist.

5.1. Häufige Fehler und wie man sie vermeidet

Die Benennung von Variablen, Funktionen und anderen Identifiern wird oft unterschätzt, was ihre Bedeutung betrifft. Zu den häufigen Fehlern gehören:

  • Verwendung generischer Namen: Namen wie daten oder info sind nicht aussagekräftig und können zu Verwirrung führen.
  • Übermäßig lange Namen: Obwohl aussagekräftige Namen gut sind, können übermäßig ausführliche Namen umständlich sein. Finden Sie ein ausgewogenes Verhältnis.
  • Unterstriche in mehrwortigen Identifiern: Go bevorzugt camelCase für Variablennamen und PascalCase für exportierte Funktionen und Typen.
  • Inkonsistente Benennungsmuster: Konsistenz bei den Benennungskonventionen hilft dabei, die Code-Struktur schnell zu verstehen.

Tipps zur Vermeidung dieser Fehler:

  • Verwenden Sie knappe und dennoch aussagekräftige Namen. Verwenden Sie beispielsweise statt daten lieber benutzerDaten, wenn es Informationen über Benutzer enthält.
  • Befolgen Sie Go's Konvention für Akronyme; halten Sie sie großgeschrieben, wie z.B. HTTPServer anstelle von HttpServer.
  • Für nicht exportierte paketweite Variablen und Konstanten sollten die Namen kurz gehalten werden, da sie einen begrenzten Geltungsbereich haben.

5.2. Refaktorisierung für bessere Namen

Die Überarbeitung des Codes zur Verbesserung von Identifiernamen kann die Lesbarkeit des Codes erheblich verbessern. So können Sie dies sicher tun:

  1. Verwenden Sie aussagekräftige Namen: Überarbeiten Sie Namen so, dass klar wird, was sie darstellen oder tun. Benennen Sie beispielsweise eine Funktion von Prozess in ProzessBenutzereingabe um, wenn dies ihre Funktion ist.
  2. Nutzen Sie Tools: Verwenden Sie Tools wie gorename, die eine sichere Umbenennung durch semantische Analyse des Go-Codes anstelle von textueller ermöglichen.
  3. Überprüfen Sie mit Kollegen: Manchmal ist das, was für Sie Sinn ergibt, für andere möglicherweise nicht klar. Peer Reviews können dabei helfen, mehrdeutige Namen zu identifizieren.
  4. Feedback einholen und iterieren: Nach den Änderungen sammeln Sie Feedback von den Nutzern der Codebasis und iterieren Sie bei Bedarf erneut über die Benennung.

Durch die Anwendung dieser Techniken stellen Sie sicher, dass Ihre Go-Codebasis sauber, verständlich und wartbar bleibt.