Rôles des macros : autonomes ou attachées
Comprendre les macros #expression et les rôles de macros @attached peer/member/accessor.
Rôles des macros : autonomes ou attachées est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.
Que sont les macros Swift ?
Les macros Swift développent le code source à la compilation et génèrent automatiquement le code répétitif, sans surcharge à l’exécution.
// Macros are invoked with # (freestanding) or @ (attached)
#warning("Fix this later")
@Observable class Counter { var count = 0 }Macros d’expression autonomes
Les macros d’expression autonomes commencent par # et produisent une valeur ou effectuent un effet secondaire.
// #stringify expands to a tuple of the value and its source string
let (val, src) = #stringify(1 + 2)
print(val, src) // 3, "1 + 2"Macros de déclaration autonomes
Les macros de déclaration autonomes émettent de nouvelles déclarations (par exemple, des fonctions ou des variables) à l’emplacement de leur utilisation.
// #makePair emits two variables
#makePair("point", x: 1, y: 2)
// expands to: let pointX = 1; let pointY = 2Macros attachées de membres
Les macros attachées @member ajoutent des propriétés stockées ou calculées, un initialiseur ou des méthodes au type auquel elles sont attachées.
@AddID
struct User { var name: String }
// Expands to: var id = UUID()Macros attachées d’accesseurs
Les macros attachées @accessor génèrent les implémentations des accesseurs en lecture et en écriture pour les propriétés stockées.
struct Point {
@Clamped(0...100)
var x: Int = 0
// accessor macro generates get/set with clamping
}Macros attachées de déclarations sœurs
Les macros de déclarations sœurs ajoutent des déclarations voisines à côté de la déclaration à laquelle elles sont attachées.
class Service {
@AddAsync
func fetchSync(completion: @escaping (Data)->Void) { ... }
// peer macro adds: func fetch() async -> Data
}Macros attachées de conformité
Les macros de conformité ajoutent à un type sa conformité à des protocoles ainsi que les implémentations requises.
@EquatableByID
struct Product { var id: Int; var name: String }
// adds: extension Product: Equatable { ... }Macros attachées d’extensions
Les macros d’extension génèrent des blocs d’extension complets pour un type, ce qui est utile pour ajouter des implémentations complexes de protocoles.
@CustomCodable
struct Config { var host: String; var port: Int }
// adds: extension Config: Codable { custom encode/decode }L’expansion des macros s’effectue à la compilation
Toutes les expansions de macros ont lieu pendant la compilation : aucun coût à l’exécution, et le code généré est visible dans Xcode.
// Right-click macro usage in Xcode → "Expand Macro"
// to see the generated source codeDéclarer une macro
Les macros sont déclarées dans une cible de macro distincte à l’aide de l’attribut @freestanding ou @attached.
@freestanding(expression)
public macro stringify<T>(_ value: T) -> (T, String)
= #externalMacro(module: "MyMacros", type: "StringifyMacro")Résumé des rôles des macros
Autonomes : #expression, #declaration. Attachées : @member, @accessor, @peer, @conformance, @extension.
// Freestanding
let result = #stringify(40 + 2)
// Attached
@Observable class Model { var count = 0 }Vérification rapide
Quel rôle de macro ajoute de nouveaux membres (comme des propriétés ou un initialiseur) au type qu’il décore ?
Récapitulatif de la leçon
Les macros autonomes (#name) produisent des valeurs ou des déclarations. Les macros attachées (@name) enrichissent les types avec des membres, des accesseurs, des déclarations sœurs, des conformités ou des extensions. Toute l’expansion a lieu à la compilation.
Questions Fréquemment Posées
La leçon « Rôles des macros : autonomes ou attachées » est-elle gratuite ?
Oui — le texte complet de « Rôles des macros : autonomes ou attachées » 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 « Rôles des macros : autonomes ou attachées » ?
Comprendre les macros #expression et les rôles de macros @attached peer/member/accessor. 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 1 sur 4.
Combien de temps prend la leçon « Rôles des macros : autonomes ou attachées » ?
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
- Rôles des macros : autonomes ou attachées
- Écrire une macro d’expression autonome
- Macros attachées aux membres pour réduire le code répétitif
- Tester et déboguer des macros