Array.prototype.reduceRight()

Probieren Sie es aus

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

const result = array.reduceRight((accumulator, currentValue) =>
  accumulator.concat(currentValue),
);

console.log(result);
// Expected output: Array [4, 5, 2, 3, 0, 1]

Syntax

reduceRight(callbackFn)
reduceRight(callbackFn, initialValue)

Parameter

callbackFn

Eine Funktion, die für jedes Element des Arrays ausgeführt wird. Ihr Rückgabewert wird beim nächsten Aufruf von callbackFn zum Wert des Parameters accumulator. Beim letzten Aufruf wird der Rückgabewert zum Rückgabewert von reduceRight(). Die Funktion wird mit den folgenden Argumenten aufgerufen:

accumulator

Der Wert, der sich aus dem vorherigen Aufruf von callbackFn ergibt. Beim ersten Aufruf ist sein Wert initialValue, falls dieser angegeben wurde; andernfalls ist es das letzte Element des Arrays.

currentValue

Der Wert des aktuellen Elements. Beim ersten Aufruf ist sein Wert das letzte Element, falls initialValue angegeben wurde; andernfalls ist es das vorletzte Element.

currentIndex

Die Indexposition von currentValue im Array. Beim ersten Aufruf ist sein Wert array.length - 1, falls initialValue angegeben wurde; andernfalls ist es array.length - 2.

array

Das Array, für das reduceRight() aufgerufen wurde.

initialValue Optional

Der Wert, der beim ersten Aufruf von callbackFn als Akkumulator verwendet wird. Wenn kein Anfangswert angegeben wird, wird das letzte Element des Arrays dafür verwendet und bei der Verarbeitung übersprungen. Ein Aufruf von reduceRight() für ein leeres Array ohne Anfangswert löst einen TypeError aus.

Rückgabewert

Der Wert, der sich aus der Reduktion ergibt.

Beschreibung

Die Methode reduceRight() ist eine iterative Methode. Sie führt eine „Reducer“-Callback-Funktion für alle Elemente des Arrays in absteigender Indexreihenfolge aus und fasst sie zu einem einzelnen Wert zusammen. Im Abschnitt über iterative Methoden erfahren Sie mehr darüber, wie diese Methoden im Allgemeinen funktionieren.

callbackFn wird nur für Array-Indizes aufgerufen, denen Werte zugewiesen sind. Für leere Positionen in spärlich besetzten Arrays wird die Funktion nicht aufgerufen.

Anders als andere iterative Methoden akzeptiert reduceRight() kein Argument thisArg. callbackFn wird immer mit undefined als this aufgerufen. Wenn callbackFn nicht im Strict Mode ausgeführt wird, wird undefined durch globalThis ersetzt.

Die Methode reduceRight() ist generisch. Sie setzt lediglich voraus, dass der Wert von this eine length-Eigenschaft und Eigenschaften mit ganzzahligen Schlüsseln hat.

Alle Hinweise zu reduce unter Wann Sie reduce() nicht verwenden sollten gelten auch für reduceRight. Da JavaScript keine Lazy-Evaluation-Semantik hat, gibt es keinen Leistungsunterschied zwischen reduce und reduceRight.

Beispiele

Wie reduceRight() ohne Anfangswert funktioniert

Der Aufruf von callbackFn durch reduceRight sieht ungefähr so aus:

arr.reduceRight((accumulator, currentValue, index, array) => {
  // …
});

Beim ersten Aufruf der Funktion können accumulator und currentValue jeweils einen von zwei Werten haben. Wurde beim Aufruf von reduceRight ein initialValue angegeben, ist accumulator gleich initialValue und currentValue gleich dem letzten Wert im Array. Wurde kein initialValue angegeben, ist accumulator gleich dem letzten Wert im Array und currentValue gleich dem vorletzten Wert.

Ist das Array leer und wurde kein initialValue angegeben, wird ein TypeError ausgelöst. Hat das Array nur ein Element (unabhängig von dessen Position) und wurde kein initialValue angegeben, oder wurde initialValue angegeben, aber das Array ist leer, wird der einzige Wert zurückgegeben, ohne callbackFn aufzurufen.

Einige beispielhafte Abläufe der Funktion sehen so aus:

[0, 1, 2, 3, 4].reduceRight(
  (accumulator, currentValue, index, array) => accumulator + currentValue,
);

Die Callback-Funktion wird viermal aufgerufen. Die Argumente und Rückgabewerte der einzelnen Aufrufe sind wie folgt:

Der Parameter array ändert sich während des Vorgangs nicht – er ist immer [0, 1, 2, 3, 4]. Der von reduceRight zurückgegebene Wert ist der Rückgabewert des letzten Callback-Aufrufs (10).

Wie reduceRight() mit einem Anfangswert funktioniert

Hier reduzieren wir dasselbe Array mit demselben Algorithmus, übergeben aber 10 als initialValue im zweiten Argument an reduceRight():

[0, 1, 2, 3, 4].reduceRight(
  (accumulator, currentValue, index, array) => accumulator + currentValue,
  10,
);

Der von reduceRight zurückgegebene Wert ist diesmal 20.

Alle Werte in einem Array summieren

const sum = [0, 1, 2, 3].reduceRight((a, b) => a + b);
// sum is 6

Eine Liste asynchroner Funktionen mit Callbacks nacheinander ausführen und die Ergebnisse jeweils an die nächste Funktion weitergeben

const waterfall =
  (...functions) =>
  (callback, ...args) =>
    functions.reduceRight(
      (composition, fn) =>
        (...results) =>
          fn(composition, ...results),
      callback,
    )(...args);

const randInt = (max) => Math.floor(Math.random() * max);

const add5 = (callback, x) => {
  setTimeout(callback, randInt(1000), x + 5);
};
const mul3 = (callback, x) => {
  setTimeout(callback, randInt(1000), x * 3);
};
const sub2 = (callback, x) => {
  setTimeout(callback, randInt(1000), x - 2);
};
const split = (callback, x) => {
  setTimeout(callback, randInt(1000), x, x);
};
const add = (callback, x, y) => {
  setTimeout(callback, randInt(1000), x + y);
};
const div4 = (callback, x) => {
  setTimeout(callback, randInt(1000), x / 4);
};

const computation = waterfall(add5, mul3, sub2, split, add, div4);
computation(console.log, 5); // Logs 14

// same as:

const computation2 = (input, callback) => {
  const f6 = (x) => div4(callback, x);
  const f5 = (x, y) => add(f6, x, y);
  const f4 = (x) => split(f5, x);
  const f3 = (x) => sub2(f4, x);
  const f2 = (x) => mul3(f3, x);
  add5(f2, input);
};

Unterschied zwischen reduce und reduceRight

const a = ["1", "2", "3", "4", "5"];
const left = a.reduce((prev, cur) => prev + cur);
const right = a.reduceRight((prev, cur) => prev + cur);

console.log(left); // "12345"
console.log(right); // "54321"

Kombinierbare Funktionen definieren

Funktionskomposition ist ein Mechanismus zum Kombinieren von Funktionen, bei dem die Ausgabe jeder Funktion an die nächste übergeben wird und die Ausgabe der letzten Funktion das Endergebnis ist. In diesem Beispiel verwenden wir reduceRight(), um Funktionskomposition zu implementieren.

Siehe auch Funktionskomposition auf Wikipedia.

const compose =
  (...args) =>
  (value) =>
    args.reduceRight((acc, fn) => fn(acc), value);

// Increment passed number
const inc = (n) => n + 1;

// Doubles the passed value
const double = (n) => n * 2;

// using composition function
console.log(compose(double, inc)(2)); // 6

// using composition function
console.log(compose(inc, double)(2)); // 5

reduceRight() mit spärlich besetzten Arrays verwenden

reduceRight() überspringt fehlende Elemente in spärlich besetzten Arrays, aber keine undefined-Werte.

console.log([1, 2, , 4].reduceRight((a, b) => a + b)); // 7
console.log([1, 2, undefined, 4].reduceRight((a, b) => a + b)); // NaN

reduceRight() für Objekte aufrufen, die keine Arrays sind

Die Methode reduceRight() liest die length-Eigenschaft von this und greift dann auf jede Eigenschaft zu, deren Schlüssel eine nichtnegative ganze Zahl kleiner als length ist.

const arrayLike = {
  length: 3,
  0: 2,
  1: 3,
  2: 4,
  3: 99, // ignored by reduceRight() since length is 3
};
console.log(Array.prototype.reduceRight.call(arrayLike, (x, y) => x - y));
// -1, which is 4 - 3 - 2

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Polyfill für Array.prototype.reduceRight in core-js
• Polyfill für Array.prototype.reduceRight von es-shims
• Leitfaden zu indizierten Sammlungen
• Array
• Array.prototype.map()
• Array.prototype.flat()
• Array.prototype.flatMap()
• Array.prototype.reduce()
• TypedArray.prototype.reduceRight()
• Object.groupBy()
• Map.groupBy()