Erstellen und Importieren von Go-Paketen

Einführung

Im vorherigen Abschnitt haben Sie ein einfaches Go-Programm erstellt, das die folgenden Codezeilen enthielt:

package main
import "fmt"

Wie verstehen wir diese beiden Codezeilen? Wie können wir die Anweisungen package und import effektiv nutzen?

In diesem Lab (Praktikum) werden Sie lernen, wie Sie Pakete in Go erstellen und importieren. Dies ermöglicht es Ihnen, Ihren Code in wiederverwendbare Module zu organisieren, wodurch Ihre Go-Projekte wartbarer und skalierbarer werden.

Wissenspunkte:

Definition und Deklaration eines Pakets
Verständnis von exportierten (öffentlichen) und nicht-exportierten (privaten) Bezeichnern
Verschiedene Formen des Paketimports: Einzelimport, gruppierter Import, Punkt-Import, Alias-Import und anonymen Import

Dies ist ein Guided Lab, das schrittweise Anweisungen bietet, um Ihnen beim Lernen und Üben zu helfen. Befolgen Sie die Anweisungen sorgfältig, um jeden Schritt abzuschließen und praktische Erfahrungen zu sammeln. Historische Daten zeigen, dass dies ein Labor der Stufe Anfänger mit einer Abschlussquote von 84% ist. Es hat eine positive Bewertungsrate von 84% von den Lernenden erhalten.

Deklaration und Definition von Paketen

Ein Paket in Go ähnelt Modulen in Python oder Bibliotheken in C. Es ist eine Sammlung von Quellcode-Dateien, die dazu dienen, Code zu organisieren und wiederzuverwenden. Jede Go-Datei muss am Anfang der Datei ein Paket deklarieren.

Hinweis: Ein Go-Programm muss genau ein Paket namens main haben, das als Einstiegspunkt für die Ausführung dient. Ohne es kann das Programm keine ausführbare Datei generieren.

Wichtige Punkte:

Exportierte (öffentliche) Bezeichner: Bezeichner (Variablen, Funktionen, Typen usw.), die mit einem Großbuchstaben beginnen, sind von anderen Paketen zugänglich. Denken Sie an diese als die öffentliche Schnittstelle Ihres Pakets.
Nicht-exportierte (private) Bezeichner: Bezeichner, die mit einem Kleinbuchstaben beginnen, sind nur innerhalb desselben Pakets zugänglich. Diese gelten als interne Implementierungsdetails des Pakets.
Paketkohesion: Alle Dateien in demselben Ordner müssen zum gleichen Paket gehören. Dies stellt sicher, dass verwandter Code zusammengehalten wird.
Paketnamenskonventionen: Paketnamen sollten klein geschrieben, kurz und beschreibend sein und Unterstriche oder Großbuchstaben vermeiden.

Lassen Sie uns unser eigenes benutzerdefiniertes Paket erstellen:

Erstellen Sie einen Ordner namens propagandist und eine Datei propagandist.go darin:
```
mkdir ~/project/propagandist
touch ~/project/propagandist/propagandist.go
```
Schreiben Sie den folgenden Code in propagandist.go:
```
package propagandist

var Shout = "I Love LabEx" // Public variable
var secret = "I love the dress" // Private variable

func Hit() string {
    return "Don't hit me, please!"
}
```
- Shout ist öffentlich, da es mit einem Großbuchstaben beginnt. Das bedeutet, dass Sie darauf von anderen Paketen zugreifen können, die propagandist importieren.
- secret ist privat, da es mit einem Kleinbuchstaben beginnt. Es kann nur innerhalb des propagandist-Pakets verwendet werden.
- Hit ist eine öffentliche Funktion, auf die von anderen Paketen zugegriffen werden kann.
Initialisieren Sie ein Go-Modul für das Paket:
```
cd ~/project/propagandist
go mod init propagandist
```
Dieser Befehl initialisiert ein neues Go-Modul im propagandist-Verzeichnis, das hilft, die Abhängigkeiten für das Paket zu verwalten.

Einzelner Paketimport

Um das propagandist-Paket zu verwenden, erstellen wir ein neues Go-Programm. Dieser Schritt zeigt, wie Sie ein einzelnes Paket in Ihrem Go-Code importieren und nutzen können.

Erstellen Sie eine neue Go-Datei namens pacExercise.go im Projektordner:
```
touch ~/project/pacExercise.go
```
Initialisieren Sie ein Go-Modul für das Programm:
```
cd ~/project
go mod init pacExercise
```
Aktualisieren Sie die go.mod-Datei, um die Abhängigkeit vom lokalen Paket hinzuzufügen. Führen Sie den folgenden Befehl im Terminal aus:
```
echo "replace propagandist =>./propagandist" >> go.mod
```
Wichtig: Dieser Befehl fügt eine replace-Direktive in Ihre go.mod-Datei ein. Dies ist wichtig, da es Go mitteilt, dass das propagandist-Paket aus dem lokalen Verzeichnis ./propagandist bezogen werden soll, anstatt es von einem Remote-Repository herunterzuladen. Sie sollten diesen Befehl in Ihrem Terminal ausführen, wodurch die Zeile replace propagandist =>./propagandist an Ihre go.mod-Datei angehängt wird. Schreiben Sie diese Zeile nicht manuell direkt in die Datei.
Schreiben Sie den folgenden Code in pacExercise.go, um das propagandist-Paket zu importieren und zu verwenden:
```
package main

import (
    "fmt"
    "propagandist"
)

func main() {
    fmt.Println(propagandist.Shout) // Access the public variable
}
```
- Dieser Code importiert das fmt-Paket zum Ausgeben von Text und das propagandist-Paket.
- Anschließend greift er auf die öffentliche Variable Shout aus dem propagandist-Paket über propagandist.Shout zu.
Führen Sie das Programm aus:
```
go mod tidy
go run pacExercise.go
```
Der Befehl go mod tidy stellt sicher, dass Ihre go.mod-Datei mit allen neuen Abhängigkeiten aktualisiert wird. Der Befehl go run pacExercise.go kompiliert und führt das Programm aus.

Erwartete Ausgabe:
```
I Love LabEx
```

Gruppierte Importe

Wenn Sie mehrere Pakete importieren, können Sie gruppierte Importe verwenden, um die Lesbarkeit und Organisation Ihres Codes zu verbessern. Dies ist eine stilistische Wahl und ändert nicht die Funktionalität Ihres Codes.

Ändern Sie pacExercise.go, um gruppierte Importe zu verwenden:
```
package main

import (
    "fmt"
    "propagandist"
)

func main() {
    fmt.Println(propagandist.Shout)
}
```
Im obigen Codeausschnitt werden die Pakete fmt und propagandist innerhalb eines einzelnen import-Blocks in Klammern importiert. Dies erleichtert das Lesen und Verwalten mehrerer Paketimporte. Dies ist genau das gleiche wie im vorherigen Beispiel und zeigt, wie die Syntax für gruppierte Importe verwendet wird.
Führen Sie das Programm aus, um zu bestätigen, dass es weiterhin funktioniert:
```
go run pacExercise.go
```
Das Programm sollte ohne Fehler ausgeführt werden und das gleiche Ergebnis wie zuvor ausgeben.

Punkt-Import

Mit einem Punkt-Import können Sie das Paketnamen-Präfix weglassen, wenn Sie Funktionen oder Variablen aus diesem Paket aufrufen. Dies wird oft abgeraten zugunsten expliziter Paketnamen, da es zu Namensraumkonflikten führen und die Lesbarkeit verringern kann. Dennoch ist es gut, zu wissen, was es ist.

Ändern Sie pacExercise.go, um einen Punkt-Import für fmt zu verwenden:
```
package main

import. "fmt"
import "propagandist"

func main() {
    Println(propagandist.Shout) // No `fmt.` prefix needed
}
```
- Hier bedeutet import. "fmt", dass Sie Funktionen und Variablen aus dem fmt-Paket direkt ohne das fmt.-Präfix verwenden können.
- Beispielsweise verwenden Sie Println anstelle von fmt.Println.
Führen Sie das Programm aus:
```
go run pacExercise.go
```
Erwartete Ausgabe:
```
I Love LabEx
```

Alias-Import

Sie können ein importiertes Paket mit einem Alias versehen, um die Klarheit zu erhöhen oder Konflikte zu vermeiden, wenn zwei Pakete ähnliche Namen haben. Dies hilft, Ihren Code lesbarer zu gestalten und Namensraum-Kollisionen zu verwalten.

Ändern Sie pacExercise.go, um fmt mit dem Alias io zu versehen:
```
package main

import io "fmt"
import "propagandist"

func main() {
    io.Println(propagandist.Shout) // Use the alias `io` instead of `fmt`
}
```
- import io "fmt" erstellt einen Alias io für das fmt-Paket.
- Jetzt verwenden Sie io.Println anstelle von fmt.Println.
Führen Sie das Programm aus:
```
go run pacExercise.go
```

Anonymer Import

Anonyme Importe werden verwendet, um ein Paket wegen seiner Nebeneffekte zu importieren, wie z. B. das Ausführen seiner init()-Funktion, ohne dass es erforderlich ist, direkt auf seine exportierten Bezeichner zu verweisen. Dies ist nützlich für Pakete, die Treiber registrieren oder andere Initialisierungsaufgaben ausführen.

Ändern Sie pacExercise.go, um einen anonymen Import für time einzufügen:
```
package main

import (
    "fmt"
    "propagandist"
    _ "time" // Anonymous import
)

func main() {
    fmt.Println(propagandist.Shout)
}
```
- import _ "time" ist ein anonymer Import. Der Unterstrich _ wird als leerer Bezeichner verwendet, um dem Compiler mitzuteilen, dass Sie das Paket wegen seiner Nebeneffekte importieren und in Ihrem Code nicht direkt auf etwas aus diesem Paket verweisen werden.
- Die init()-Funktion des time-Pakets wird ausgeführt, wenn dieses Programm läuft. Das time-Paket hat hier keine sichtbaren besonderen Nebeneffekte. Viele Pakete nutzen dies jedoch, um Datenbanktreiber oder Konfigurationseinstellungen zu registrieren.
Führen Sie das Programm aus:
```
go run pacExercise.go
```
Erwartete Ausgabe:
```
I Love LabEx
```

Zusammenfassung

In diesem Lab haben Sie gelernt:

Wie man benutzerdefinierte Pakete in Go erstellt und definiert, um wiederverwendbaren Code zu kapseln.
Der Unterschied zwischen öffentlichen (exportierten) und privaten (nicht exportierten) Bezeichnern und wie sie die Zugänglichkeit beeinflussen.
Verschiedene Methoden zum Importieren von Paketen, jede mit ihrem Anwendungsfall:
- Einzelner Import: Importieren eines Pakets nach dem anderen.
- Gruppierter Import: Importieren mehrerer Pakete in einem einzigen Block für eine bessere Organisation.
- Punkt-Import: Importieren eines Pakets und direktes Verwenden seiner Bezeichner ohne das Paketnamen-Präfix. (Mit Vorsicht verwenden)
- Alias-Import: Umbenennen importierter Pakete für eine bessere Lesbarkeit oder zur Vermeidung von Namenskonflikten.
- Anonymer Import: Importieren eines Pakets ausschließlich wegen seiner Nebeneffekte, wie z. B. Initialisierung.
Die Rolle der init()-Funktion in Paketen und wie anonyme Importe deren Ausführung auslösen können.

Durch die Absolvierung dieses Labs sind Sie nun in der Lage, Go-Projekte effektiv mit Paketen zu strukturieren und zu verwalten. Sie können wiederverwendbare Module erstellen, den Zugang zu Bezeichnern steuern und Ihren Code besser organisieren, was zu wartbareren und skalierbaren Go-Anwendungen führt.

Summary

In this lab, you learned:

How to create and define custom packages in Go, encapsulating reusable code.
The difference between public (exported) and private (unexported) identifiers and how they impact accessibility.
Various ways to import packages, each with its use case:
- Single-item import: Importing one package at a time.
- Grouped import: Importing multiple packages in a single block for better organization.
- Dot import: Importing a package and using its identifiers directly without the package name prefix. (Use with caution)
- Alias import: Renaming imported packages for better readability or to avoid naming conflicts.
- Anonymous import: Importing a package solely for its side effects, such as initialization.
The role of the init() function in packages and how anonymous imports can trigger its execution.
The detailed workings of Go's initialization process, including:
- How package-level variables are initialized before init() functions
- The guaranteed execution order of init() functions across dependent packages
- How multiple init() functions work within a package
- The complete initialization flow from dependent packages to the main function

By completing this lab, you are now equipped to structure and manage Go projects using packages effectively. You can create reusable modules, control access to identifiers, better organize your code, and understand the initialization process, leading to more maintainable and scalable Go applications.