Swift Academy · Leçon

async let et tâches enfants concurrentes

Exécuter simultanément des opérations async indépendantes avec des liaisons async let.

Leçon 3 sur 412 étapes

async let et tâches enfants concurrentes est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Bienvenue

`async let` exécute plusieurs opérations asynchrones en parallèle — elles démarrent toutes immédiatement, et `await` attend leurs résultats lorsque cela est nécessaire.

Séquentiel ou concurrent

```swift // Sequential — slow: let a = try await fetchA() let b = try await fetchB() // Concurrent with async let — fast: async let a = fetchA() async let b = fetchB() let (resultA, resultB) = try await (a, b) ```

Syntaxe de async let

```swift async let title = fetchTitle(id) async let author = fetchAuthor(id) async let content = fetchContent(id) let article = Article( title: try await title, author: try await author, content: try await content ) ```

Tout ou rien

Si une liaison `async let` génère une erreur, celle-ci est propagée. Le système annule automatiquement les tâches sœurs.

async let dans les boucles

```swift var results: [Data] = [] await withTaskGroup(of: Data.self) { group in for url in urls { group.addTask { try await URLSession.shared.data(from: url).0 } } for await data in group { results.append(data) } } ```

TaskGroup

```swift await withTaskGroup(of: Int.self) { group in for i in 1...5 { group.addTask { i * i } } var squares: [Int] = [] for await square in group { squares.append(square) } print(squares.sorted()) // [1,4,9,16,25] } ```

ThrowingTaskGroup

```swift try await withThrowingTaskGroup(of: User.self) { group in for id in ids { group.addTask { try await fetchUser(id: id) } } for try await user in group { process(user) } } ```

Arbre de concurrence structurée

`async let` et TaskGroup forment un arbre de tâches. Les tâches parentes attendent tous leurs enfants. L’annulation de la tâche parente annule tous ses enfants.

Quand utiliser async let plutôt que TaskGroup

• `async let` — nombre fixe d’opérations concurrentes connu lors de la compilation • `TaskGroup` — nombre dynamique de tâches, par exemple pour traiter un tableau

Limiter la concurrence avec TaskGroup

```swift await withTaskGroup(of: Void.self) { group in let concurrency = 4 var running = 0 for url in urls { if running >= concurrency { await group.next() } group.addTask { await process(url) } running += 1 } } ```

Vérification rapide

Qu’arrive-t-il aux tâches sœurs `async let` si l’une d’elles génère une erreur ?

Réponds-y dans la leçon interactive

Récapitulatif

Points essentiels : • `async let x = asyncWork()` — démarre immédiatement, en parallèle • `try await x` — attend le résultat • Tout ou rien : un échec annule les tâches sœurs • `withTaskGroup` — ensemble dynamique de tâches concurrentes • La concurrence structurée = gestion automatique des tâches enfants Ensuite : les acteurs.

Gratuit pour commencer

Apprends Swift avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 122
Leçons: 409

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « async let et tâches enfants concurrentes » est-elle gratuite ?

Oui — le texte complet de « async let et tâches enfants concurrentes » 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 « async let et tâches enfants concurrentes » ?

Exécuter simultanément des opérations async indépendantes avec des liaisons async let. 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 3 sur 4.

Combien de temps prend la leçon « async let et tâches enfants concurrentes » ?

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

Syntaxe async/await et appel de fonctions asynchrones
Task et annulation de Task
async let et tâches enfants concurrentes
Acteurs : protéger l’état mutable partagé

← Retour à Swift Academy