Array.prototype.reduceRight() — Methode · JavaScript-Referenz

Signatur

Array.prototype.reduceRight(callbackFn, initialValue)

Beschreibung

reduceRight() arbeitet genau wie reduce(), beginnt aber beim letzten Element und läuft bis zum ersten. Der Rückgabewert jedes Callback-Aufrufs wird beim nächsten Aufruf als Akkumulator übergeben. Am Ende steht ein einzelner Wert, zum Beispiel eine Zahl, ein String, ein Objekt oder eine Funktion.

Sinnvoll ist die Methode immer dann, wenn die Reihenfolge eine Rolle spielt: beim Verketten von Funktionen im Stil der mathematischen Komposition (compose(f, g)(x) === f(g(x))), beim Aufbau verschachtelter Strukturen von innen nach außen (etwa Middleware-Ketten oder verkettete Listen) oder wenn Zeichen oder Elemente in umgekehrter Reihenfolge zusammengesetzt werden sollen, ohne das Array vorher mit reverse() zu verändern.

Wird initialValue angegeben, startet der Akkumulator mit diesem Wert und der erste Aufruf erhält das letzte Element. Fehlt er, wird das letzte Element zum Startwert und der erste Aufruf erhält das vorletzte. Lücken in sparse Arrays werden übersprungen. Das ursprüngliche Array wird nicht verändert, außer der Callback tut das selbst.

Parameter

Name	Typ	Default	Beschreibung
$callbackFn Pflicht	(accumulator: any, currentValue: any, currentIndex: number, array: Array) => any		Wird für jedes vorhandene Element von rechts nach links aufgerufen. Der Rückgabewert wird zum neuen `accumulator`. Die Argumente sind `accumulator` (bisheriges Ergebnis), `currentValue` (aktuelles Element), `currentIndex` (sein Index) und `array` (das Array selbst).
$initialValue	any		Startwert für den Akkumulator. Fehlt er, wird das letzte Element als Startwert genommen und die Iteration beginnt beim vorletzten Element.

Rückgabewert

Typ

any

Beschreibung

Der Wert, der nach der vollständigen Reduktion übrig bleibt, also der Rückgabewert des letzten Callback-Aufrufs. Bei einem leeren Array mit initialValue ist das initialValue selbst.

Beispiele

Reihenfolge der Verarbeitung sichtbar machen

const buchstaben = ['a', 'b', 'c', 'd'];

const links = buchstaben.reduce((acc, b) => acc + b, '');
const rechts = buchstaben.reduceRight((acc, b) => acc + b, '');

console.log(links);
console.log(rechts);

abcd dcba

Funktionskomposition (compose) von rechts nach links

const compose = (...fns) => (wert) =>
  fns.reduceRight((acc, fn) => fn(acc), wert);

const trim = (s) => s.trim();
const klein = (s) => s.toLowerCase();
const slug = (s) => s.replace(/\s+/g, '-');

// Ausführung: erst trim, dann klein, dann slug
const zuSlug = compose(slug, klein, trim);

console.log(zuSlug('  Hallo Welt JavaScript  '));

hallo-welt-javascript

Middleware-Kette von innen nach außen aufbauen

const middlewares = [
  (next) => (req) => { console.log('Logger'); return next(req); },
  (next) => (req) => { console.log('Auth');   return next({ ...req, user: 'anna' }); },
];

const handler = (req) => `Antwort für ${req.user} auf ${req.pfad}`;

// Die letzte Middleware umschließt den Handler direkt
const pipeline = middlewares.reduceRight((next, mw) => mw(next), handler);

console.log(pipeline({ pfad: '/profil' }));

Logger Auth Antwort für anna auf /profil

Verschachtelte Arrays von rechts abflachen

const verschachtelt = [[0, 1], [2, 3], [4, 5]];

const flach = verschachtelt.reduceRight((acc, teil) => acc.concat(teil), []);

console.log(flach);

[4, 5, 2, 3, 0, 1]

// Wichtig · Fallstricke

TypeError bei leerem Array: [].reduceRight(fn) ohne initialValue wirft TypeError: Reduce of empty array with no initial value. Gib deshalb möglichst immer einen Startwert an.
Nur ein Element: Ohne initialValue und mit genau einem Element wird dieses Element zurückgegeben, ohne dass der Callback aufgerufen wird. Das gilt auch, wenn das Array leer ist, aber ein initialValue angegeben wurde.
Typen im Akkumulator: Ohne Startwert hat der Akkumulator den Typ des letzten Elements. Bei Objekt-Arrays führt das leicht zu Fehlern wie [object Object]-Strings oder NaN.
Sparse Arrays: Lücken werden übersprungen, explizite undefined-Werte dagegen nicht.
Änderungen während der Iteration: Der Indexbereich wird vor dem ersten Aufruf festgelegt. Nachträglich angehängte Elemente werden nicht besucht, gelöschte Elemente werden übersprungen.
Kein Abbruch möglich: Es gibt kein break. Für einen frühen Abbruch eignen sich eine for-Schleife oder findLast() besser.
Die Methode ist generisch und funktioniert auch mit Array-ähnlichen Objekten, etwa Array.prototype.reduceRight.call(arguments, fn, 0). Auf TypedArrays gibt es sie als TypedArray.prototype.reduceRight().
Kompatibilität: Die Methode wird von allen modernen Browsern und Node.js unterstützt, im Internet Explorer ab Version 9.

Siehe auch

Array.prototype.reduce() Array.prototype.map() Array.prototype.reverse() Array.prototype.toReversed() Array.prototype.findLast() Array.prototype.flat() Array