Go Academy · Lekcja

Pakiety internal i obszary robocze

internal/, dyrektywy replace i go work

Pakiety internal i obszary robocze to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 4 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.

Katalog internal/

Pakiety znajdujące się w katalogu internal/ mogą być importowane wyłącznie przez kod z drzewa katalogów nadrzędnych. W ten sposób wymuszana jest hermetyzacja pakietów:

// Project structure:
// myapp/
//   main.go
//   internal/
//     auth/auth.go      <- can only be imported by myapp/
//     db/db.go          <- can only be imported by myapp/
//   api/
//     handlers.go       <- can import myapp/internal/auth

// External package CANNOT do:
// import "myapp/internal/auth"  <- compile error

Korzystanie z pakietów internal/

Kod znajdujący się w tym samym module (powyżej katalogu internal/) może bez ograniczeń importować pakiety wewnętrzne:

// myapp/api/handlers.go
package api

import (
    "myapp/internal/auth"
    "myapp/internal/db"
)

func GetUser(id int) (*db.User, error) {
    if !auth.IsValid() {
        return nil, auth.ErrUnauthorized
    }
    return db.FindUser(id)
}

Dlaczego używać internal/?

Korzyści z konwencji internal/:

Uniemożliwia innym modułom zależność od szczegółów implementacji
Pozwala swobodnie refaktoryzować kod bez psucia zewnętrznych wywołań
Jasno sygnalizuje, że dany element nie należy do publicznego API
Standardowe narzędzia Go egzekwują to ograniczenie na etapie kompilacji

Przestrzenie robocze Go — go work

W Go 1.18 wprowadzono przestrzenie robocze, które umożliwiają jednoczesną pracę z wieloma lokalnymi modułami bez używania dyrektyw replace:

# Create a workspace in parent directory:
go work init ./myapp ./mylib

# Creates go.work:
# go 1.21
# use (
#     ./myapp
#     ./mylib
# )

# Now myapp can import mylib without replace directives

go work sync

Zsynchronizuj zależności przestrzeni roboczej za pomocą go work sync:

# go.work file:
go 1.21

use (
    ./api
    ./worker
    ./shared
)

# Sync all module dependencies:
go work sync

# Build across all workspace modules:
go build ./...

# Test across all workspace modules:
go test ./...

Przestrzeń robocza a dyrektywa replace

Porównanie dwóch sposobów lokalnego programowania obejmującego wiele modułów:

// BEFORE workspaces (cumbersome):
// go.mod in myapp:
// replace github.com/me/mylib => ../mylib
// Must remove before publishing!

// WITH workspaces (cleaner):
// go.work at root:
// use (./myapp ./mylib)
// go.mod files stay clean — go.work is gitignored

Zastosowania przestrzeni roboczych

Kiedy używać przestrzeni roboczych Go:

Jednoczesne tworzenie biblioteki i korzystającej z niej aplikacji
Monorepo z wieloma odwołującymi się do siebie modułami
Testowanie zmian we współdzielonym module przed jego opublikowaniem
Praca nad forkiem zależności równolegle z pracą nad aplikacją

go work add i go work use

Zarządzaj wpisami przestrzeni roboczej za pomocą podpoleceń go work:

# Add a module to the workspace
go work use ./newservice

# Remove a module from workspace
go work use -r ./oldservice

# Edit go.work directly (opens $EDITOR):
go work edit

# go.work should usually be gitignored:
echo "go.work" >> .gitignore
echo "go.work.sum" >> .gitignore

internal/ i workspace razem

Pakiety wewnętrzne i przestrzenie robocze naturalnie się uzupełniają w monorepo:

// Monorepo structure:
// services/
//   go.work
//   auth-service/
//     internal/tokens/   <- private to auth-service
//   order-service/
//     internal/pricing/  <- private to order-service
//   shared/
//     models/            <- shared across services

// go.work:
// use (./auth-service ./order-service ./shared)

Najlepsze praktyki organizacji pakietów

Zalecany układ projektu Go:

Płaska struktura pakietów w małych projektach — należy unikać przedwczesnego porządkowania
Używaj internal/ do przechowywania szczegółów implementacji, które nie są przeznaczone do użytku zewnętrznego
Umieszczaj główne pakiety CLI w katalogach cmd/appname/
Używaj przestrzeni roboczych w repozytoriach wielomodułowych, ale dodaj go.work do pliku ignorowanych plików Git
Unikaj głębokiego zagnieżdżania — maksymalnie 3–4 poziomy pakietów

Szybki test

Kto może importować pakiet znajdujący się w katalogu internal/?

Podsumowanie: pakiety wewnętrzne i przestrzenie robocze

Podsumowanie:

internal/ ogranicza importy do drzewa katalogów nadrzędnych — jest to egzekwowane przez kompilator
Używaj internal/, aby ukrywać szczegóły implementacji przed zewnętrznymi użytkownikami
go work init tworzy przestrzeń roboczą na potrzeby lokalnego programowania wielomodułowego
Przestrzenie robocze zastępują dyrektywy replace podczas lokalnego programowania
Dodaj go.work i go.work.sum do pliku ignorowanych plików Git

Często zadawane pytania

Czy lekcja „Pakiety internal i obszary robocze” jest bezpłatna?

Tak — pełny tekst „Pakiety internal i obszary robocze” 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 internal i obszary robocze”?

internal/, dyrektywy replace i go work Ć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 4 z 4.

Ile czasu zajmuje lekcja „Pakiety internal i obszary robocze”?

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