Swift Academy · Leçon

reduce et reduce(into:)

Agrégerez des collections en une seule valeur.

reduce et reduce(into:) 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.

Qu’est-ce que reduce ?

reduce regroupe toute une séquence en une seule valeur en combinant à plusieurs reprises un accumulateur avec chaque élément.

Vous fournissez une valeur de départ
Ainsi qu’une fermeture (accumulator, element) -> accumulator

Faire une somme avec reduce

L’exemple classique — tout additionner :

let nums = [1, 2, 3, 4]
let total = nums.reduce(0) { acc, x in acc + x }
print(total)  // 10

Raccourci avec un opérateur

Lorsque la fermeture se résume à un opérateur, vous pouvez transmettre directement la fonction opérateur :

let nums = [1, 2, 3, 4]
print(nums.reduce(0, +))   // 10
print(nums.reduce(1, *))   // 24

Réduire vers un autre type

Le type du résultat peut différer de celui des éléments :

let words = ["a", "b", "c"]
let joined = words.reduce("") { $0 + $1.uppercased() }
print(joined)  // "ABC"

Trouver un maximum avec reduce

Vous pouvez calculer d’autres agrégats que des sommes :

let nums = [3, 9, 2, 7]
let maxVal = nums.reduce(Int.min) { max($0, $1) }
print(maxVal)  // 9

Le coût de reduce

Un reduce classique crée un tout nouvel accumulateur à chaque étape. Pour les types valeur comme String ou Array, cela signifie copier l’intégralité de l’accumulateur à chaque élément — un travail en O(n²) pour les grandes entrées.

Voici reduce(into:)

reduce(into:) transmet l’accumulateur comme paramètre inout, ce qui permet de le modifier sur place au lieu de le copier :

let nums = [1, 2, 2, 3, 3, 3]
let counts = nums.reduce(into: [Int: Int]()) { dict, n in
    dict[n, default: 0] += 1
}
print(counts)  // [1: 1, 2: 2, 3: 3]

Construire efficacement un tableau

reduce(into:) est particulièrement efficace lorsque l’on accumule des éléments dans une collection :

let nums = [1, 2, 3, 4, 5]
let evensSquared = nums.reduce(into: [Int]()) { result, n in
    if n % 2 == 0 { result.append(n * n) }
}
print(evensSquared)  // [4, 16]

reduce et reduce(into:)

Même résultat, caractéristiques de performance différentes :

let parts = ["a", "b", "c"]
let a = parts.reduce("") { $0 + $1 }            // copies each step
let b = parts.reduce(into: "") { $0 += $1 }    // mutates in place
print(a, b)  // abc abc

Regrouper avec reduce(into:)

Un motif fréquent : regrouper les éléments par clé :

let names = ["Ann", "Al", "Bo", "Cy"]
let byInitial = names.reduce(into: [Character: [String]]()) { dict, name in
    dict[name.first!, default: []].append(name)
}
print(byInitial[Character("A")]!)  // ["Ann", "Al"]

Choisir entre les deux

Utilisez reduce pour les accumulateurs scalaires peu coûteux (Int, Double). Utilisez reduce(into:) dès que l’accumulateur est une collection ou un autre type valeur volumineux, afin d’éviter les copies.

let nums = [1, 2, 3]
print(nums.reduce(0, +))                          // scalar: plain reduce
print(nums.reduce(into: Set<Int>()) { $0.insert($1) }) // collection: into

Vérification rapide

Pourquoi préférer reduce(into:) lors de la construction d’un dictionnaire ou d’un tableau ?

Récapitulatif

Vous avez appris la réduction :

reduce(initial) { acc, x in ... } réduit une séquence à une seule valeur
Raccourci avec un opérateur : reduce(0, +)
reduce(into:) modifie un accumulateur inout ; utilisez-le pour les collections
Très utile pour les comptes, les regroupements et les jointures

Ensuite : flatMap et l’enchaînement.

Questions Fréquemment Posées

La leçon « reduce et reduce(into:) » est-elle gratuite ?

Oui — le texte complet de « reduce et reduce(into:) » 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 « reduce et reduce(into:) » ?

Agrégerez des collections en une seule valeur. 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 « reduce et reduce(into:) » ?

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

← Retour à Swift Academy