0Pricing
Swift Academy · Leçon

Concurrence structurée et fonctions asynchrones

Définissez des fonctions async , appelez-les avec await et comprenez la concurrence structurée : les tâches enfants se terminent avant la sortie de la portée parente.

Concurrence structurée et fonctions asynchrones est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 async/await ?

async/await vous permet d’écrire du code asynchrone qui se lit comme du code synchrone. Avec la concurrence structurée, les tâches enfants sont liées à la durée de vie de leur portée : aucune fuite.

Votre première fonction asynchrone

Une fonction async peut utiliser await avec d’autres opérations asynchrones. Créez une Task dans un script ou un environnement de test pour l’appeler.

// Simulate a short async delay, then return a value
func fetchNumber() async -> Int {
    try? await Task.sleep(nanoseconds: 200_000_000) // ~200ms
    return 42
}

// Call sites must use "await" from an async context or a Task
Task {
    let n = await fetchNumber()
    print("Fetched:", n)  // 42
}

Suspension, puis reprise

await suspend la tâche jusqu’à ce que le résultat soit prêt, puis l’exécution reprend proprement à la ligne suivante.

func greet(after seconds: Double) async -> String {
    let ns = UInt64(seconds * 1_000_000_000)
    try? await Task.sleep(nanoseconds: ns)
    return "Hello after \(Int(seconds))s"
}

Task {
    print(await greet(after: 1.0))
    print("Back on the same task after await.")
}

Notions de async let

Utilisez async let pour démarrer des tâches enfants. Elles appartiennent à la portée actuelle et doivent être attendues avant la sortie de cette portée.

// Run child tasks concurrently within the same scope
func fetchUser() async -> String { "Ana" }
func fetchScore() async -> Int { 90 }

Task {
    async let name = fetchUser()
    async let score = fetchScore()
    // Both start immediately; await joins them before use
    let summary = await "\(name): \(score)"
    print(summary) // "Ana: 90"
    // Scope ends -> child tasks are awaited automatically (structured)
}

Les parents rejoignent les enfants

Structurée signifie que les tâches parentes ne peuvent pas se terminer avant leurs enfants. Cela évite le travail orphelin et rend les durées de vie prévisibles.

// Parent Task encapsulates children lifetimes
func loadProfile() async -> String {
    async let name = fetchUser()
    async let score = fetchScore()
    return await "\(name) (\(score))"
}

Task {
    let profile = await loadProfile()
    print(profile) // e.g., "Ana (90)"
    // loadProfile does not return until its children are done
}

Recommandations

Conseils :

  • Raisonnez en termes de tâches, pas de fils d’exécution.
  • Utilisez async let pour les tâches sœurs ; utilisez await avant de sortir de la portée.
  • Utilisez Task.sleep pour les démonstrations ; dans les applications réelles, attendez les opérations réseau ou d’E/S de fichiers.

Définition de await

Vérification rapide : que fait await ?

Récapitulatif

Récapitulatif : marquez les fonctions avec async et appelez-les avec await. Utilisez async let pour démarrer des tâches sœurs et comptez sur la concurrence structurée pour terminer les enfants avant les parents.

Questions Fréquemment Posées

La leçon « Concurrence structurée et fonctions asynchrones » est-elle gratuite ?

Oui — le texte complet de « Concurrence structurée et fonctions asynchrones » 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 « Concurrence structurée et fonctions asynchrones » ?

Définissez des fonctions async , appelez-les avec await et comprenez la concurrence structurée : les tâches enfants se terminent avant la sortie de la portée parente. 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 3.

Combien de temps prend la leçon « Concurrence structurée et fonctions asynchrones » ?

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. Concurrence structurée et fonctions asynchrones
  2. async let, Task et annulation
  3. try await et propagation des erreurs
← Retour à Swift Academy