0Pricing
Go Academy · Lektion

Packages: Go-Code organisieren

Package-Deklarationen, Imports und exportierte Namen

Packages: Go-Code organisieren ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist ein Package?

Jede Go-Quelldatei gehört zu einem Package. Der Package-Name steht oben in jeder Datei. Packages gruppieren zusammengehörigen Code und steuern die Sichtbarkeit:

// file: math/calc.go
package math

// Exported — accessible from other packages (capital letter)
func Add(a, b int) int { return a + b }

// Unexported — package-private (lowercase)
func helper() int { return 42 }

Package-Deklaration und Importpfad

Der Package-Name (Kurzform) unterscheidet sich vom Importpfad (vollständiger Modulpfad bzw. Verzeichnispfad):

// Import path: github.com/myapp/util/stringutil
// Package name: stringutil (last segment by convention)
package stringutil

func Reverse(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

Packages importieren

Verwenden Sie import, um andere Packages einzubinden. Go verlangt, dass alle Importe verwendet werden:

package main

import (
    "fmt"                         // standard library
    "strings"                     // standard library
    "github.com/myapp/util/math"  // third-party or local
)

func main() {
    fmt.Println(strings.ToUpper("hello"))
    fmt.Println(math.Add(1, 2))
}

Exportierte und nicht exportierte Bezeichner

Bezeichner, die mit einem Großbuchstaben beginnen, sind exportiert (öffentlich). Bezeichner mit Kleinbuchstaben sind nicht exportiert (paketprivat):

package server

// Exported: accessible from other packages
type Server struct {
    Addr    string   // exported field
    timeout int      // unexported field
}

// Exported method
func (s *Server) Start() error { return nil }

// Unexported helper
func (s *Server) listen() {}

Package main und func main

Das main-Package ist besonders — es definiert eine ausführbare Datei. Die main-Funktion ist der Einstiegspunkt:

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
    // Program starts here and ends here
}

// All other packages are libraries — no main() needed

init()-Funktion

Jedes Package kann eine oder mehrere init()-Funktionen enthalten, die automatisch vor main() und in der Reihenfolge ihrer Deklaration ausgeführt werden:

package config

import "fmt"

var DB string

func init() {
    DB = "localhost:5432/mydb"
    fmt.Println("config package initialized")
}

// init runs once when the package is first imported
// Multiple init() functions per file/package are allowed

Blank-Import für Seiteneffekte

Importieren Sie ein Package ausschließlich wegen der Seiteneffekte seiner init()-Funktionen, indem Sie den Blank-Identifier verwenden:

package main

import (
    "database/sql"
    _ "github.com/lib/pq"  // registers PostgreSQL driver via init()
)

func main() {
    db, err := sql.Open("postgres", "host=localhost dbname=test")
    _ = db
    _ = err
}

Importe mit Alias

Benennen Sie ein Package beim Import um, um Namenskonflikte zu vermeiden oder den Namen zu verkürzen:

package main

import (
    "fmt"
    gomath "math"              // alias to avoid collision
    mymath "github.com/me/math"
)

func main() {
    fmt.Println(gomath.Sqrt(16))     // 4
    fmt.Println(mymath.Add(1, 2))    // 3
}

Konventionen für Package-Namen

Konventionen für Go-Package-Namen:

  • Kurz, kleingeschrieben, ein einzelnes Wort: http, json, fmt
  • Entspricht dem Verzeichnisnamen: util/stringutil/ → Package stringutil
  • Keine Unterstriche oder camelCase in Package-Namen
  • Vermeiden Sie allgemeine Namen wie util, common, helper
  • Der Package-Name ist Teil des Bezeichners: Bevorzugen Sie http.Client gegenüber httplib.HTTPClient

Zirkuläre Importe

Go erlaubt KEINE zirkulären Importe. Package A kann B nicht importieren, wenn B A importiert. Lösen Sie das Problem, indem Sie den gemeinsamen Code in ein drittes Package auslagern:

// WRONG: A imports B, B imports A — compile error
// package a imports "myapp/b"
// package b imports "myapp/a"

// SOLUTION: extract shared types to package c
// package a imports "myapp/c"
// package b imports "myapp/c"
// No circular dependency

Wissenscheck

Wodurch wird ein Bezeichner in Go exportiert?

Zusammenfassung: Packages

Wichtige Konzepte zu Packages:

  • Jede Datei beginnt mit package name
  • Großbuchstaben = exportiert (öffentlich), Kleinbuchstaben = nicht exportiert (paketprivat)
  • Importieren Sie über den vollständigen Pfad und verwenden Sie den kurzen Package-Namen
  • init() wird automatisch vor main() ausgeführt
  • Blank-Import _ "pkg" nur für Seiteneffekte
  • Keine zirkulären Importe erlaubt

Häufig gestellte Fragen

Ist die Lektion „Packages: Go-Code organisieren“ kostenlos?

Ja — der vollständige Text von „Packages: Go-Code organisieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Packages: Go-Code organisieren“?

Package-Deklarationen, Imports und exportierte Namen Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Packages: Go-Code organisieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Packages: Go-Code organisieren
  2. Go-Module mit go mod
  3. Externe Abhängigkeiten hinzufügen
  4. Interne Packages und Workspaces
← Zurück zu Go Academy