0Pricing
Swift Academy · Leçon

Packages locaux et modules fonctionnels

Extraire des fonctionnalités dans des packages Swift locaux pour accélérer les compilations et isoler le code.

Packages locaux et modules fonctionnels est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Pourquoi des modules de fonctionnalités ?

Diviser une application en paquets locaux renforce l’encapsulation, accélère les compilations incrémentielles et permet aux équipes de travailler en parallèle.

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

Créer un paquet local

Créez un dossier à côté de votre projet Xcode et exécutez swift package init à l’intérieur.

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

Ajouter un paquet au projet Xcode

Faites glisser le dossier du paquet local dans le navigateur de projet de Xcode. Xcode le détecte automatiquement comme un paquet SPM.

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

Référencer un paquet local

Dans le Package.swift de votre application (ou via Xcode), référencez les paquets locaux avec .package(path:).

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

Surface de l’API publique

Seules les déclarations public et open du paquet local sont accessibles depuis l’application. Utilisez le contrôle d’accès pour définir la frontière du module.

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

Implémentation interne

Tous les types internal sont invisibles en dehors du module, ce qui impose automatiquement l’encapsulation.

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

Structure d’un module de fonctionnalité

Chaque module de fonctionnalité possède en interne ses propres couches Domaine, Données et Présentation.

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

Module central partagé

Extrayez les préoccupations transversales (réseau, analytique, système de conception) dans un module partagé importé par les modules de fonctionnalités.

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

Graphe des dépendances

Les modules de fonctionnalités ne doivent pas dépendre directement les uns des autres. Les dépendances partagées passent par un module central afin d’éviter le couplage.

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

Avantages sur le temps de compilation

Grâce à des frontières de modules propres, Xcode ne reconstruit que les modules concernés lorsque les fichiers sources changent.

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

Tester les modules de fonctionnalités

Chaque module de fonctionnalité possède sa propre cible de test, ce qui permet l’exécution parallèle des tests et accélère l’intégration continue.

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

Vérification rapide

Quel niveau d’accès est requis pour que les déclarations d’un paquet Swift local puissent être utilisées depuis la cible de l’application ?

Récapitulatif de la leçon

Créez des paquets locaux de fonctionnalités avec swift package init, référencez-les via .package(path:) et n’exposez que des types public. Extrayez les utilitaires partagés dans un module central. Les modules de fonctionnalités ne doivent pas dépendre les uns des autres. Des frontières de modules propres réduisent considérablement les temps de compilation incrémentielle.

Questions Fréquemment Posées

La leçon « Packages locaux et modules fonctionnels » est-elle gratuite ?

Oui — le texte complet de « Packages locaux et modules fonctionnels » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Packages locaux et modules fonctionnels » ?

Extraire des fonctionnalités dans des packages Swift locaux pour accélérer les compilations et isoler le code. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Packages locaux et modules fonctionnels » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Package.swift : cibles, produits et dépendances
  2. Packages locaux et modules fonctionnels
  3. Cibles binaires et XCFrameworks
  4. Gestion des versions, résolution des conflits et plugins Swift
← Retour à Swift Academy