Swift Academy · Lekcja

Pakiety lokalne i moduły funkcji

Wydzielanie funkcji do lokalnych pakietów Swift w celu przyspieszenia kompilacji i izolacji.

Lekcja 2 z 413 kroki

Pakiety lokalne i moduły funkcji to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 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 Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Dlaczego moduły funkcjonalne

Podział aplikacji na lokalne pakiety wymusza enkapsulację, przyspiesza kompilacje przyrostowe i umożliwia równoległą pracę zespołu.

// Without modules: one giant target recompiles everything
// With modules: changes to FeatureA only recompile FeatureA

Tworzenie lokalnego pakietu

Należy utworzyć katalog obok projektu Xcode i uruchomić w nim swift package init.

mkdir Features/UserProfile
cd Features/UserProfile
swift package init --name UserProfile --type library

Dodawanie do projektu Xcode

Należy przeciągnąć katalog lokalnego pakietu do nawigatora projektu Xcode. Xcode automatycznie rozpozna go jako pakiet SPM.

// In Xcode:
// File → Add Package Dependencies → Add Local...
// Select the package directory

Odwoływanie się do lokalnego pakietu

W pliku Package.swift aplikacji (lub za pomocą Xcode) należy wskazać lokalne pakiety za pomocą .package(path:).

.package(path: "../Features/UserProfile"),
// In the target:
.product(name: "UserProfile", package: "UserProfile")

Publiczny interfejs API

Z aplikacji dostępne są tylko deklaracje public i open w lokalnym pakiecie. Kontrola dostępu służy do definiowania granicy modułu.

// UserProfile/Sources/UserProfile/ProfileView.swift
public struct ProfileView: View {
  public init() {}
  public var body: some View { Text("Profile") }
}

Implementacja wewnętrzna

Wszystkie typy internal są niewidoczne poza modułem, co automatycznie wymusza enkapsulację.

// Only visible within UserProfile module:
final class ProfileCache { ... }
struct ProfileMapper { ... }

Struktura modułu funkcjonalnego

Każdy moduł funkcjonalny ma wewnątrz własne warstwy domeny, danych i prezentacji.

// UserProfile/
// ├── Sources/UserProfile/
// │   ├── Domain/         (entities, use cases, protocols)
// │   ├── Data/           (repositories)
// │   └── Presentation/   (views, view models)
// └── Tests/UserProfileTests/

Wspólny moduł Core

Elementy przekrojowe (obsługę sieci, analitykę i system projektowy) należy wydzielić do wspólnego modułu importowanego przez moduły funkcjonalne.

// CoreNetwork package
// CoreDesign package
// Both imported by FeatureA and FeatureB

Graf zależności

Moduły funkcjonalne nie powinny zależeć od siebie bezpośrednio. Współdzielone zależności powinny przepływać przez moduł Core, aby uniknąć sprzężenia.

// GOOD:
// FeatureA → CoreNetwork
// FeatureB → CoreNetwork
// BAD:
// FeatureA → FeatureB  (tight coupling)

Korzyści dotyczące czasu kompilacji

Dzięki przejrzystym granicom modułów Xcode ponownie kompiluje tylko zmienione moduły, gdy zmieniają się pliki źródłowe.

// Change in UserProfile → only UserProfile recompiles
// App target links the new binary → fast incremental build

Testowanie modułów funkcjonalnych

Każdy moduł funkcjonalny ma własny target testów, co umożliwia równoległe wykonywanie testów i przyspiesza CI.

// Run all tests:
swift test --package-path Features/UserProfile
// Or let Xcode run them as part of the main test plan

Szybkie sprawdzenie

Jaki poziom dostępu jest wymagany, aby deklaracje w lokalnym pakiecie Swift mogły być używane z targetu aplikacji?

Odpowiedz w interaktywnej lekcji

Podsumowanie lekcji

Należy tworzyć lokalne pakiety funkcjonalne za pomocą swift package init, wskazywać je przez .package(path:) i udostępniać wyłącznie typy public. Współdzielone narzędzia należy wydzielać do modułu Core. Moduły funkcjonalne nie powinny zależeć od siebie nawzajem. Przejrzyste granice modułów znacząco skracają czas kompilacji przyrostowej.

Bezpłatny start

Ucz się Swift 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: 122
Lekcje: 409

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

Często zadawane pytania

Czy lekcja „Pakiety lokalne i moduły funkcji” jest bezpłatna?

Tak — pełny tekst „Pakiety lokalne i moduły funkcji” 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 Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Pakiety lokalne i moduły funkcji”?

Wydzielanie funkcji do lokalnych pakietów Swift w celu przyspieszenia kompilacji i izolacji. Ćwiczysz Swift 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ąć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift 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 2 z 4.

Ile czasu zajmuje lekcja „Pakiety lokalne i moduły funkcji”?

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 Swift Academy?

Tak. Każda lekcja Swift 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

Package.swift: cele, produkty i zależności
Pakiety lokalne i moduły funkcji
Cele binarne i XCFrameworks
Wersjonowanie, rozwiązywanie konfliktów i wtyczki Swift

← Powrót do Swift Academy