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

Signatur

TypedArray.prototype.reduceRight(callbackFn, initialValue)

Beschreibung

reduceRight() ruft die übergebene Funktion für jedes Element eines typisierten Arrays (Int8Array, Uint8Array, Float32Array, BigInt64Array usw.) auf. Anders als bei reduce() läuft es vom letzten zum ersten Index. Der Rückgabewert jedes Aufrufs wird als Akkumulator an den nächsten Aufruf weitergegeben. Am Ende steht ein einzelner Wert, zum Beispiel eine Summe, eine Zeichenkette oder ein Objekt.

Der Algorithmus ist derselbe wie bei Array.prototype.reduceRight(). Weil typisierte Arrays immer dicht besetzt sind und nur Zahlen (bzw. BigInt) enthalten, gibt es keine Lücken, die übersprungen werden. Die Länge wird einmal zu Beginn gelesen.

Die Richtung spielt eine Rolle, wenn die Reihenfolge das Ergebnis ändert. Das gilt etwa für nicht-kommutative Operationen wie Subtraktion oder das Zusammensetzen von Zeichenketten, für die Auswertung von Polynomen nach dem Horner-Schema oder für die Umrechnung von Byte-Folgen im Little-Endian-Format in eine Zahl.

Ohne initialValue dient das letzte Element als Startwert, und die Verarbeitung beginnt beim vorletzten Element. Bei einem leeren Array ohne Startwert wird ein TypeError ausgelöst.

Parameter

Name	Typ	Default	Beschreibung
$callbackFn Pflicht	(accumulator: any, currentValue: number \| bigint, currentIndex: number, array: TypedArray) => any		Wird für jedes Element von rechts nach links aufgerufen. Sie erhält `accumulator` (das bisherige Ergebnis), `currentValue` (das aktuelle Element), `currentIndex` (dessen Index) und `array` (das typisierte Array selbst). Ihr Rückgabewert wird zum neuen Akkumulator.
$initialValue	any	letztes Element des Arrays	Startwert des Akkumulators beim ersten Aufruf. Fehlt er, wird das letzte Element verwendet und die Verarbeitung beginnt beim vorletzten Index.

Rückgabewert

Typ

any

Beschreibung

Der Wert, den der letzte Aufruf von callbackFn zurückgibt. Enthält das Array genau ein Element und fehlt initialValue, wird dieses Element zurückgegeben, ohne dass die Funktion aufgerufen wird. Ist das Array leer und initialValue angegeben, wird initialValue zurückgegeben.

Beispiele

Richtung sichtbar machen: Subtraktion und Zeichenkette

const werte = new Int16Array([10, 20, 30]);

// ohne Startwert: 30 - 20 - 10
const differenz = werte.reduceRight((acc, v) => acc - v);
console.log(differenz);

// Zeichenkette in umgekehrter Reihenfolge aufbauen
const text = werte.reduceRight((acc, v) => `${acc}${v},`, '');
console.log(text);

0 30,20,10,

Little-Endian-Bytes in eine Zahl umwandeln

// 4 Bytes Little-Endian: 0x78 0x56 0x34 0x12 → 0x12345678
const bytes = new Uint8Array([0x78, 0x56, 0x34, 0x12]);

// Vom höchstwertigen Byte (rechts) zum niedrigsten (links)
const zahl = bytes.reduceRight((acc, byte) => acc * 256 + byte, 0);

console.log(zahl.toString(16));
console.log(zahl);

12345678 305419896

Polynom mit dem Horner-Schema auswerten

// Koeffizienten aufsteigend: 2 + 3x + 1x² → p(x) = x² + 3x + 2
const koeff = new Float64Array([2, 3, 1]);

const auswerten = (x) => koeff.reduceRight((acc, a) => acc * x + a, 0);

console.log(auswerten(2)); // 4 + 6 + 2
console.log(auswerten(-1)); // 1 - 3 + 2

12 0

BigInt64Array und leeres Array absichern

const gross = new BigInt64Array([1n, 2n, 3n]);
// Der Startwert muss ein BigInt sein, sonst gibt es einen TypeError (Mischung aus BigInt und Number)
const produkt = gross.reduceRight((acc, v) => acc * v, 1n);
console.log(produkt);

const leer = new Float32Array(0);
try {
  leer.reduceRight((acc, v) => acc + v);
} catch (err) {
  console.log(err.name);
}
// mit Startwert kein Fehler
console.log(leer.reduceRight((acc, v) => acc + v, 0));

6n TypeError 0

// Wichtig · Fallstricke

Leeres Array ohne Startwert: Das löst einen TypeError aus. Gib deshalb immer einen initialValue an, wenn das Array leer sein könnte.
BigInt-Arrays: Bei BigInt64Array und BigUint64Array muss der Startwert ebenfalls ein BigInt sein (z. B. 0n). Wer number und bigint mischt, bekommt einen TypeError.
Der Akkumulator ist nicht begrenzt: Das Ergebnis ist ein normaler JavaScript-Wert und wird nicht auf den Elementtyp gekürzt. Eine Summe über ein Uint8Array kann also größer als 255 werden. Nur beim Zurückschreiben ins Array wird der Wert abgeschnitten.
Gleitkomma-Genauigkeit: Bei Float32Array sind die Elemente bereits auf 32 Bit gerundet (z. B. 0.1 → 0.10000000149011612). Außerdem kann die Summierrichtung das Ergebnis minimal verändern.
Verändern während des Durchlaufs: Die Länge wird am Anfang festgelegt. Schreibt man während des Durchlaufs in das Array, sieht der Callback die geänderten Werte. Wird der zugrunde liegende ArrayBuffer abgekoppelt (detached) oder verkleinert, liefern die fehlenden Indizes undefined.
Performance: Bei großen numerischen Daten, etwa Audio- oder Bildpuffern, ist eine einfache for-Schleife oft schneller als der Aufruf einer Funktion für jedes Element.
Kompatibilität: Wird seit ES2015 in allen modernen Browsern und seit Node.js 4 unterstützt.

Siehe auch

TypedArray.prototype.reduce() Array.prototype.reduceRight() TypedArray.prototype.map() TypedArray.prototype.forEach() TypedArray.prototype.reverse() TypedArray