Die Methode Array.prototype.reduce() wird verwendet, um alle Elemente eines Arrays zu einem einzigen Wert zu reduzieren. Dabei kann der Rückgabewert der Callback-Funktion von einer Iteration zur nächsten weitergereicht werden, was diese Methode ideal für komplexe Berechnungen, Summierungen, Gruppierungen und Transformationen von Arrays macht.

01 · Abschnitt

Syntax

JavaScript Syntax 
Array.prototype.reduce(callbackFn(accumulator, currentValue[, currentIndex[, array]])[, initialValue])
Parameter
callbackFn

Die Funktion, die auf jedes Element des Arrays angewendet wird. Sie hat vier Parameter:

  • accumulator: Der akkumulierte Wert, der das Ergebnis der Reduzierung speichert.
  • currentValue: Das aktuelle Element des Arrays, das gerade verarbeitet wird.
  • currentIndex: (Optional) Der Index des aktuellen Elements
  • array: (Optional) Das Array, auf dem die Methode aufgerufen wurde.
initialValue

(Optional) Der Wert, der als Startwert für den Akkumulator verwendet wird. Wenn kein Wert angegeben wird, wird das erste Element des Arrays als Startwert verwendet und die Iteration beginnt mit dem zweiten Element.

02 · Abschnitt

Rückgabewert

Die Methode gibt den akkumulierten Endwert zurück, nachdem die Callback-Funktion auf jedes Element angewendet wurde.

03 · Abschnitt

Beispiele

Summe eines Arrays von Zahlen mit dem Startwert 0

JavaScript Beispiel 
const nums = [1, 2, 3, 4];

const sum = nums.reduce(function(accumulator, currentValue) {
    return accumulator + currentValue;
}, 0);

console.log(sum);
Output 
10

Maximales Element in einem Array

JavaScript Beispiel 
const nums = [10, 20, 5, 30];

const maxValue = nums.reduce(function(accumulator, currentValue) {
    return Math.max(accumulator, currentValue);
}, 0);

console.log(maxValue);
Output 
30

Gruppieren von Objekten nach Eigenschaft

JavaScript Beispiel 
const people = [
    { name: "John", age: 30 },
    { name: "Tom", age: 30 },
    { name: "Alice", age: 25 }
];

const grouped = people.reduce((accumulator, person) => {
    const age = person.age;
    if (!accumulator[age]) {
        accumulator[age] = [];
    }
    accumulator[age].push(person);
    return accumulator;
}, {});

console.log(grouped);
Output 
{
    '25': [ { name: 'Alice', age: 25 } ],
    '30': [ { name: 'John', age: 30 }, { name: 'Tom', age: 30 } ]
}

Hier werden Personen nach dem Alter gruppiert. Der accumulator beginnt als leeres Objekt {} und bei jeder Iteration wird überprüft, ob eine Liste für das aktuelle Alter existiert. Wenn nicht, wird sie erstellt und die Person wird der entsprechenden Gruppe hinzugefügt.

Verkettung von Strings

JavaScript Beispiel 
const words = ["JavaScript", "is", "awesome"];

const sentence = words.reduce((accumulator, currentValue) => {
    return accumulator + " " + currentValue;
});

console.log(sentence);
Output 
JavaScript is awesome
/ Weiter

Zurück zu Array

Zur Übersicht