0Pricing
Swift Academy · Aula

Pacotes locais e módulos de funcionalidades

Extraia funcionalidades para pacotes Swift locais para obter compilações mais rápidas e isolamento.

Pacotes locais e módulos de funcionalidades é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Por que Usar Módulos de Funcionalidade?

Dividir um aplicativo em pacotes locais reforça o encapsulamento, acelera as compilações incrementais e permite o desenvolvimento paralelo pelas equipes.

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

Criação de um Pacote Local

Crie um diretório ao lado do projeto do Xcode e execute swift package init dentro dele.

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

Adição ao Projeto do Xcode

Arraste o diretório do pacote local para o navegador de projetos do Xcode. O Xcode o detecta automaticamente como um pacote SPM.

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

Referência a um Pacote Local

No Package.swift do aplicativo, ou pelo Xcode, faça referência aos pacotes locais com .package(path:).

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

Superfície da API Pública

Somente as declarações public e open do pacote local podem ser acessadas pelo aplicativo. Use o controle de acesso para definir o limite do módulo.

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

Implementação Interna

Todos os tipos internal ficam invisíveis fora do módulo, reforçando o encapsulamento automaticamente.

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

Estrutura do Módulo de Funcionalidade

Cada módulo de funcionalidade contém internamente suas próprias camadas de Domínio, Dados e Apresentação.

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

Módulo Principal Compartilhado

Extraia preocupações transversais, como rede, análise e sistema de design, para um módulo compartilhado importado pelos módulos de funcionalidade.

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

Grafo de Dependências

Os módulos de funcionalidade não devem depender diretamente uns dos outros. As dependências compartilhadas devem passar por um módulo Principal para evitar acoplamento.

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

Benefícios para o Tempo de Compilação

Com limites de módulo bem definidos, o Xcode recompila apenas os módulos afetados quando os arquivos de código-fonte são alterados.

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

Testes dos Módulos de Funcionalidade

Cada módulo de funcionalidade tem seu próprio destino de teste, permitindo a execução paralela dos testes e uma CI mais rápida.

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

Verificação Rápida

Qual nível de acesso é necessário para que as declarações de um pacote Swift local possam ser usadas pelo destino do aplicativo?

Recapitulação da lição

Crie pacotes locais de funcionalidades com swift package init, faça referência a eles por meio de .package(path:) e exponha apenas tipos public. Extraia utilitários compartilhados para um módulo Principal. Os módulos de funcionalidade não devem depender uns dos outros. Limites de módulo bem definidos reduzem drasticamente os tempos de compilação incremental.

Perguntas Frequentes

A aula “Pacotes locais e módulos de funcionalidades” é grátis?

Sim — o texto completo de “Pacotes locais e módulos de funcionalidades” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Pacotes locais e módulos de funcionalidades”?

Extraia funcionalidades para pacotes Swift locais para obter compilações mais rápidas e isolamento. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Pacotes locais e módulos de funcionalidades”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Package.swift: destinos, produtos e dependências
  2. Pacotes locais e módulos de funcionalidades
  3. Destinos binários e XCFrameworks
  4. Versionamento, resolução de conflitos e plugins do Swift
← Voltar para Swift Academy