0Pricing
Swift Academy · Leçon

API à portée limitée et modèles de lisibilité

Appliquez des API à portée limitée et des conventions de nommage pour les DSL : utilisez des jetons d’espace de noms, regroupez avec des fonctions auxiliaires et gardez des blocs courts et explicites.

API à portée limitée et modèles de lisibilité est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. 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 3 leçons au total.

Pourquoi limiter la portée d'un DSL ?

Les DSL lisibles limitent ce que vous pouvez faire dans un bloc et nomment clairement les éléments. Utilisez des espaces de noms, de petites fonctions auxiliaires et le regroupement pour garder l'intention évidente.

Modèle d'espace de noms

Placer les jetons sous R réduit l'interface et évite les conflits avec les symboles de l'application ; les appels restent courts et faciles à parcourir.

struct Route { let method: String; let path: String }

// Namespace instead of global free functions
enum R {
    static func GET(_ path: String) -> Route  { Route(method: "GET",  path: path) }
    static func POST(_ path: String) -> Route { Route(method: "POST", path: path) }
}

@resultBuilder
struct RoutesBuilder {
    static func buildBlock(_ parts: Route...) -> [Route] { parts }
}

func routes(@RoutesBuilder _ content: () -> [Route]) -> [Route] { content() }

let table = routes {
    R.GET("/home")
    R.POST("/upload")
}
for r in table { print("\(r.method) \(r.path)") }

Fonction auxiliaire de regroupement

Utilisez une petite fonction auxiliaire de regroupement pour ajouter du contexte (préfixe, étiquettes) sans vous répéter ; le bloc reste ordonné.

// Group routes by a shared prefix using a helper
func section(_ prefix: String, @RoutesBuilder _ content: () -> [Route]) -> [Route] {
    content().map { Route(method: $0.method, path: prefix + $0.path) }
}

let grouped = routes {
    R.GET("/health")
    section("/admin") {
        R.GET("/dashboard")
        R.POST("/upload")
    }
}
for r in grouped { print("\(r.method) \(r.path)") } // /admin/* prefixed

Séparer les responsabilités

Préférez de petits créateurs pour séparer les responsabilités (routes et middlewares). Chaque bloc n'expose que ce dont il a besoin.

// A separate builder for middlewares (keeps concerns isolated)
struct Middleware { let name: String }

@resultBuilder
struct MiddlewareBuilder {
    static func buildBlock(_ parts: Middleware...) -> [Middleware] { parts }
}

enum M {
    static func log(_ name: String) -> Middleware { Middleware(name: "log:\(name)") }
    static func auth() -> Middleware { Middleware(name: "auth") }
}

func middlewares(@MiddlewareBuilder _ content: () -> [Middleware]) -> [Middleware] { content() }

let mw = middlewares {
    M.log("requests")
    M.auth()
}
print(mw.map(\.name))

Conseils de lisibilité

Modèles :

  • Utilisez des verbes courts : GET, POST, auth.
  • Gardez une action par ligne.
  • Préférez les blocs à plat ; imbriquez-les uniquement pour ajouter du contexte.
  • Donnez des étiquettes explicites aux fonctions auxiliaires (par exemple, prefix:).

Fonction auxiliaire de validation

Fournissez de petites fonctions auxiliaires de validation pour garantir la validité des blocs. Échouez rapidement avec des messages utiles.

// Add a simple validator to catch mistakes early
func validate(_ routes: [Route]) -> [String] {
    var issues: [String] = []
    let seen = Set(routes.map { $0.method + " " + $0.path })
    if seen.count != routes.count { issues.append("Duplicate route detected") }
    if routes.contains(where: { !$0.path.hasPrefix("/") }) {
        issues.append("Paths must start with /")
    }
    return issues
}

let issues = validate(grouped)
print(issues.isEmpty ? "OK" : "Issues: \(issues)")

Modèle d'API à portée limitée

Vérification rapide : quel choix rend un bloc DSL plus sûr et plus clair ?

Récapitulatif

Récapitulatif : limitez la portée de votre DSL avec des espaces de noms, utilisez de petites fonctions auxiliaires de regroupement, gardez les blocs ciblés et validez tôt pour obtenir un code plus sûr et plus lisible.

Questions Fréquemment Posées

La leçon « API à portée limitée et modèles de lisibilité » est-elle gratuite ?

Oui — le texte complet de « API à portée limitée et modèles de lisibilité » 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 3 leçons au total.

Qu'est-ce que j'apprendrai dans « API à portée limitée et modèles de lisibilité » ?

Appliquez des API à portée limitée et des conventions de nommage pour les DSL : utilisez des jetons d’espace de noms, regroupez avec des fonctions auxiliaires et gardez des blocs courts et explicites. 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 3.

Combien de temps prend la leçon « API à portée limitée et modèles de lisibilité » ?

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. Créer des mini-DSL avec les générateurs de résultats
  2. API à portée limitée et modèles de lisibilité
  3. Exemples pratiques sans frameworks d’interface utilisateur
← Retour à Swift Academy