Go Academy · Lekcja

Pakiety: organizowanie kodu Go

Deklaracje pakietów, importy i eksportowane nazwy

Lekcja 1 z 412 kroki

Pakiety: organizowanie kodu Go to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Czym jest pakiet?

Każdy plik źródłowy Go należy do pakietu. Nazwa pakietu znajduje się na początku każdego pliku. Pakiety grupują powiązany kod i kontrolują jego widoczność:

// 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 }

Deklaracja pakietu i ścieżka importu

Nazwa pakietu (krótka) różni się od ścieżki importu (pełnej ścieżki modułu/katalogu):

// 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)
}

Importowanie pakietów

Użyj import, aby dołączyć inne pakiety. Go wymaga użycia wszystkich importów:

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))
}

Eksportowane i nieeksportowane identyfikatory

Identyfikatory rozpoczynające się wielką literą są eksportowane (publiczne). Identyfikatory rozpoczynające się małą literą są nieeksportowane (prywatne w obrębie pakietu):

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() {}

Pakiet main i func main

Pakiet main jest wyjątkowy — definiuje program wykonywalny. Funkcja main jest punktem wejścia:

package main

import "fmt"

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

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

Funkcja init()

Każdy pakiet może zawierać jedną lub więcej funkcji init(), które są uruchamiane automatycznie przed main(), w kolejności deklaracji:

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

Pusty import dla efektów ubocznych

Zaimportuj pakiet wyłącznie dla efektów ubocznych jego funkcji init(), używając pustego identyfikatora:

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
}

Importy z aliasami

Zmień nazwę pakietu podczas importowania, aby uniknąć konfliktów nazw lub skrócić zapis:

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
}

Konwencje nazewnictwa pakietów

Konwencje nazewnictwa pakietów Go:

Krótkie, pisane małymi literami, jednowyrazowe nazwy: http, json, fmt
Zgodność z nazwą katalogu: util/stringutil/ → pakiet stringutil
W nazwach pakietów nie należy używać podkreśleń ani zapisu camelCase
Należy unikać ogólnych nazw, takich jak util, common, helper
Nazwa pakietu jest częścią identyfikatora: preferuj http.Client zamiast httplib.HTTPClient

Importy cykliczne

Go NIE zezwala na importy cykliczne. Pakiet A nie może importować pakietu B, jeśli B importuje A. Aby rozwiązać ten problem, należy wydzielić wspólny kod do trzeciego pakietu:

// 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

Szybki test

Co sprawia, że identyfikator w Go jest eksportowany?

Odpowiedz w interaktywnej lekcji

Podsumowanie: pakiety

Najważniejsze informacje o pakietach:

Każdy plik zaczyna się od package name
Wielka litera oznacza identyfikator eksportowany (publiczny), a mała — nieeksportowany (prywatny w obrębie pakietu)
Importuj za pomocą pełnej ścieżki, a używaj krótkiej nazwy pakietu
init() uruchamia się automatycznie przed main()
Pusty import _ "pkg" służy wyłącznie do uzyskania efektów ubocznych
Importy cykliczne są niedozwolone

Bezpłatny start

Ucz się Go dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 51
Lekcje: 203

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Pakiety: organizowanie kodu Go” jest bezpłatna?

Tak — pełny tekst „Pakiety: organizowanie kodu Go” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Pakiety: organizowanie kodu Go”?

Deklaracje pakietów, importy i eksportowane nazwy Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Pakiety: organizowanie kodu Go”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy