Start · Sprachen · JavaScript · Referenz · TypedArray.prototype.every()

TypedArray.prototype.every()

Methode

Prüft, ob alle Elemente eines typisierten Arrays die Testfunktion erfüllen, und gibt <code>true</code> oder <code>false</code> zurück.

seit JavaScript ES2015 Kategorie: method-property

Signatur

TypedArray.prototype.every(callbackFn, thisArg)

Beschreibung

every() ruft die übergebene Testfunktion für jedes Element eines typisierten Arrays (z. B. Uint8Array, Float32Array) der Reihe nach auf. Sobald die Funktion einmal einen falsy Wert liefert, bricht die Methode sofort ab und gibt false zurück. Erfüllen alle Elemente den Test, ist das Ergebnis true.

Die Methode verhält sich wie Array.prototype.every(), ist aber auf typisierte Arrays zugeschnitten: Es gibt keine Lücken (sparse Slots), und alle Elemente sind Zahlen bzw. bei BigInt64Array/BigUint64Array BigInts. Typische Einsatzfälle sind Validierungen von Binärdaten, etwa ob alle Bytes eines Puffers null sind, ob Messwerte in einem gültigen Bereich liegen oder ob ein Bild vollständig transparent ist.

Wichtig: Bei einem leeren typisierten Array liefert every() immer true (leere Wahrheit). Die Methode verändert das Array selbst nicht, die Testfunktion könnte es aber verändern – davon ist abzuraten.

Parameter

Name Typ Default Beschreibung
$callbackFn Pflicht (element: number | bigint, index: number, array: TypedArray) => unknown Testfunktion, die für jedes Element aufgerufen wird. Erhält element (aktueller Wert), index (Position) und array (das typisierte Array selbst). Ein truthy Rückgabewert bedeutet „Test bestanden“.
$thisArg any undefined Wert, der innerhalb von callbackFn als this verwendet wird. Wirkt nicht bei Pfeilfunktionen.

Rückgabewert

Typ
boolean
Beschreibung
true, wenn callbackFn für jedes Element einen truthy Wert liefert (oder das Array leer ist), sonst false.

Beispiele

Einfache Prüfung: alle Werte positiv?

const werte = new Int16Array([12, 5, 8, 130, 44]);
const allePositiv = werte.every((wert) => wert > 0);
console.log(allePositiv);

const gemischt = new Int16Array([12, -5, 8]);
console.log(gemischt.every((wert) => wert > 0));
true false

Prüfen, ob ein Puffer nur aus Nullbytes besteht

const istLeererPuffer = (buffer) => new Uint8Array(buffer).every((byte) => byte === 0);

const puffer = new ArrayBuffer(16);
console.log(istLeererPuffer(puffer));

new Uint8Array(puffer)[3] = 255;
console.log(istLeererPuffer(puffer));
true false

Sensor-Messwerte gegen Grenzwerte validieren (mit thisArg)

const grenzen = { min: -40, max: 85 };
const temperaturen = new Float32Array([21.5, 23.1, 19.8, 90.2]);

const gueltig = temperaturen.every(function (t) {
  return t >= this.min && t <= this.max;
}, grenzen);

console.log(gueltig ? 'Alle Werte gültig' : 'Ausreißer gefunden');
Ausreißer gefunden

Vollständig transparentes Bild erkennen (Canvas-ImageData)

const canvas = document.createElement('canvas');
canvas.width = canvas.height = 10;
const ctx = canvas.getContext('2d');
const { data } = ctx.getImageData(0, 0, 10, 10); // Uint8ClampedArray, RGBA

// Nur jeden vierten Wert (Alpha-Kanal) prüfen
const transparent = data.every((wert, i) => i % 4 !== 3 || wert === 0);
console.log(transparent);
true

// Wichtig · Fallstricke

  • Leeres Array: new Uint8Array(0).every(() => false) liefert true – bei Validierungen ggf. zusätzlich length > 0 prüfen.
  • Kurzschluss: Die Iteration stoppt beim ersten falsy Ergebnis; Seiteneffekte in callbackFn werden daher nicht für alle Elemente ausgeführt.
  • BigInt-Arrays: Bei BigInt64Array/BigUint64Array sind die Elemente BigInts – Vergleiche wie wert > 0 funktionieren, Rechnungen mit Number (wert + 1) werfen dagegen einen TypeError; 0n verwenden.
  • Nicht generisch: Anders als Array.prototype.every() funktioniert die Methode nur mit echten typisierten Arrays; ein Aufruf per call() auf normalen Arrays wirft einen TypeError.
  • Abgetrennter Puffer: Ist der zugrunde liegende ArrayBuffer (z. B. nach postMessage mit Transfer) abgetrennt, wird ein TypeError geworfen.
  • Performance: Für sehr große Puffer in heißen Schleifen kann eine klassische for-Schleife schneller sein als der Funktionsaufruf pro Element.
  • Kompatibilität: in allen modernen Browsern und Node.js seit Jahren verfügbar (Baseline).