Antwort.

Der Mechanismus reduce gehört zu den funktionalen Operationen auf Datensammlungen und kam aus funktionalen Programmiersprachen in Swift (map-reduce, fold). Historisch ermöglicht diese Funktion, jede Sammlung in einen einzigen aggregierten Wert zu transformieren (z.B. Summe, Produkt, String-Vereinigung usw.), indem sie alle ihre Elemente durchläuft und das Ergebnis akkumuliert. Das grundlegende Problem, das sie löst, ist die prägnante, lesbare und fehlerfreie Aggregation von Daten anstelle von manuellen Schleifen.

In Swift ist reduce als Methode für Sammlungen definiert:

func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result

Das bedeutet, dass Sie einen Ausgangswert (Initialwert) angeben und dann eine Funktion schreiben, die für jedes Element und den aktuellen Akkumulator einen neuen aggregierten Wert zurückgibt.

Beispielcode:

let numbers = [1, 2, 3, 4]
let sum = numbers.reduce(0) { $0 + $1 } // 10
let joined = numbers.reduce("") { $0 + String($1) } // "1234"

Hauptmerkmale:

• Ermöglicht das Schreiben von Aggregationen von Sammlungen in einer einzigen Codezeile
• Garantiert das Fehlen von Nebenwirkungen — ändert die Sammlungen nicht, arbeitet funktional
• Kann für beliebige Typen verwendet werden (nicht nur für Zahlen), auch mit Fehlerübertragung (throws)

Fangfragen.

Wie funktioniert reduce auf einer leeren Sammlung?

Reduce wird auf jedes Element der Sammlung angewendet. Wenn die Sammlung leer ist, wird der Ausgangswert zurückgegeben, es gibt keine Aufrufe der Closure.

Beispielcode:

let empty: [Int] = []
let sum = empty.reduce(100) { $0 + $1 } // 100

Kann man mit reduce die Ausgangssammlung ändern?

Nein, reduce ist eine reine Funktion, sie verändert die Ausgangssammlung nicht. Alle Änderungen passieren nur am Akkumulator.

Was ist der Unterschied zwischen reduce und reduce(into:)?

reduce(into:) ermöglicht es, den Akkumulator bei jedem Durchlauf zu mutieren und arbeitet effizienter mit Werttypen, bei denen das Erstellen einer neuen Kopie (copy-on-write) teuer ist.

Beispielcode:

let nums = [1, 2, 3]
let squares = nums.reduce(into: []) { (result: inout [Int], item) in
    result.append(item * item)
}
// squares == [1, 4, 9]

Typische Fehler und Anti-Patterns

• Falsche Wahl des Anfangswertes (z.B. bei der Aggregation mit Multiplikation — 0 anstelle von 1)
• Nebenwirkungen innerhalb der reduce-Closure (z.B. Änderung von externen Variablen)
• Verwendung von reduce für Aufgaben, die besser mit anderen Funktionen gelöst werden können (z.B. filter, map)

Beispiel aus dem Leben

Negativer Fall

Ein Entwickler wollte die Preise von Produkten summieren, die in einem Array products gespeichert sind. Er verwendete reduce mit einem Ausgangswert von 0.0, aber die Closure war so gestaltet, dass sie manchmal eine negative Summe bei Rabatten zurückgab, was zu falschen Endergebnissen und Problemen bei der Steuerberechnung führte.

Vorteile:

• Prägnanter Code
• Keine manuellen Schleifen

Nachteile:

• Der Fehler wurde erst in der Produktion sichtbar
• Falscher Geschäftswert der Endsumme

Positiver Fall

Verwendete reduce(into:), um einen Cache aus einem Array von Entitäten nach ID zu erstellen:

let objects: [Entity] = ...
let cache = objects.reduce(into: [:]) { $0[$1.id] = $1 }

Vorteile:

• Schnell, effizient, kein Kopieren des Arrays
• Klare Typisierung des Caches

Nachteile:

• Der code reduce(into:) ist für Anfänger etwas weniger lesbar
• Werte bei doppelten Schlüsseln können versehentlich überschrieben werden