Array.prototype.every() prüft, ob alle Elemente eines Arrays einen Predicate-Callback erfüllen. Sobald ein Element falsy zurückgibt, bricht die Methode ab und liefert false — Short-Circuit. Bei einem leeren Array gibt sie true zurück; das ist die logische „vacuous truth", die Anfänger oft überrascht. Das Gegenstück ist some() — gibt true, sobald irgendein Element passt. Beide sind Boolean-Predicates, anders als filter (das gefilterte Werte zurückgibt) und find (das das erste passende Element liefert).

01 · Signatur & Grundform

Signatur & Grundform

JavaScript signatur.js 
arr.every(predicate: (el: T, i: number, arr: T[]) => boolean, thisArg?): boolean
JavaScript grundform.js 
const zahlen = [2, 4, 6, 8];

// Alle gerade?
console.log(zahlen.every(n => n % 2 === 0));     // true

// Alle > 5?
console.log(zahlen.every(n => n > 5));            // false

// Mit gemischtem Array
const mix = [2, 4, 5, 8];
console.log(mix.every(n => n % 2 === 0));         // false — wegen 5
Output 
true
false
false
02 · Short-Circuit

Short-Circuit beim ersten falsy

Sobald das Predicate falsy liefert, bricht every ab. Das macht die Methode effizient für lange Arrays.

JavaScript short-circuit.js 
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let zaehler = 0;

const result = arr.every(n => {
    zaehler++;
    return n < 5;   // bricht ab, sobald n >= 5
});

console.log(result);         // false
console.log('Iterationen:', zaehler);   // 5 — nicht 10
Output 
false
Iterationen: 5

Im Vergleich zu filter, das immer das ganze Array durchläuft, kann every bei großen Daten deutlich schneller sein.

03 · Leeres Array — vacuous truth

Leeres Array — true (vacuous truth)

every auf einem leeren Array gibt true zurück. Das ist die mathematische „vacuous truth": wenn es kein Element gibt, das den Predicate verletzt, ist die Aussage „alle erfüllen" trivial wahr.

JavaScript leer.js 
console.log([].every(x => x > 100));    // true
console.log([].every(x => false));      // true
console.log([].every(Boolean));         // true

// Manchmal nicht gewollt
function alleVolljaehrig(personen) {
    return personen.every(p => p.alter >= 18);
}
console.log(alleVolljaehrig([]));        // true — gewollt?

// Mit zusätzlichem Length-Check:
function alleVolljaehrigSicher(personen) {
    return personen.length > 0 && personen.every(p => p.alter >= 18);
}
console.log(alleVolljaehrigSicher([])); // false
Output 
true
true
true
true
false

Anfänger erwarten oft false für leere Arrays. Wer „alle sind volljährig UND es gibt mindestens einen" prüfen will, braucht einen zusätzlichen Length-Check.

04 · every vs. some

every vs. some — Negierung

every und some sind komplementär über De Morgan:

  • every(p) ≡ !some(x => !p(x))
  • some(p) ≡ !every(x => !p(x))
JavaScript every-vs-some.js 
const arr = [1, 2, 3, 4, 5];

// Sind ALLE gerade?
console.log(arr.every(n => n % 2 === 0));         // false

// Gibt es MINDESTENS einen geraden?
console.log(arr.some(n => n % 2 === 0));          // true

// Sind ALLE ungerade? — Negierung
console.log(!arr.some(n => n % 2 === 0));         // false

// Gibt es einen, der NICHT gerade ist? — Negierung
console.log(arr.some(n => n % 2 !== 0));          // true
Output 
false
true
false
true

Auch some hat Short-Circuit — sobald ein Element truthy liefert, bricht es ab.

05 · Object-Validierung

Object-Validierung

every ist ideal, um Sammlungen auf Korrektheit zu prüfen.

JavaScript validierung.js 
const form = [
    { feld: 'email',    wert: 'a@b.de', valid: true },
    { feld: 'password', wert: '12345',  valid: false },
];

const formularKomplett = form.every(f => f.valid);
console.log('Formular OK?', formularKomplett);

// Mit Detail-Info
const fehler = form.filter(f => !f.valid).map(f => f.feld);
if (!formularKomplett) console.log('Fehler in:', fehler);
Output 
Formular OK? false
Fehler in: [ 'password' ]
06 · every mit Type-Guard (TypeScript)

every mit Type-Guard (TypeScript-Hinweis)

In TypeScript-Code lässt sich every mit einem Type-Predicate kombinieren, um Type-Narrowing zu erreichen:

TypeScript type-guard.ts 
function isString(x: unknown): x is string {
    return typeof x === 'string';
}

function processAllStrings(arr: unknown[]) {
    if (arr.every(isString)) {
        // hier ist arr: string[]
        return arr.join(', ');
    }
    return 'gemischte Werte';
}

In reinem JavaScript hat das keinen Effekt — nur TypeScript nutzt das Type-Predicate für Narrowing.

07 · Sparse Arrays

Sparse Arrays

Wie map und filter überspringt every Löcher in sparse Arrays — sie zählen nicht als „nicht erfüllt".

JavaScript sparse.js 
const sparse = [2, , 4, , 6];
console.log(sparse.every(n => n % 2 === 0));     // true
// Die Löcher werden nicht getestet — Predicate gibt nicht false für sie zurück
Output 
true
08 · Praxis-Beispiele

Praxis-Beispiele

JavaScript praxis.js 
// Alle URLs sind HTTPS
const urls = ['https://a.de', 'https://b.de', 'https://c.de'];
console.log(urls.every(u => u.startsWith('https://')));   // true

// Alle Antworten sind ok
const responses = [{ ok: true }, { ok: true }, { ok: false }];
console.log(responses.every(r => r.ok));                   // false

// Alle Zahlen positiv
console.log([1, 2, 3].every(n => n > 0));                  // true

// Alle Objekte haben Property 'id'
const items = [{ id: 1 }, { id: 2 }, { name: 'X' }];
console.log(items.every(i => 'id' in i));                  // false
Output 
true
false
true
false
09 · Insights

Interessantes

Leeres Array liefert true — vacuous truth

Mathematisch: „alle Elemente erfüllen P" ist trivial wahr, wenn es keine Elemente gibt. Praktisch: [].every(...) ist true. Wer „mindestens eines existiert UND alle erfüllen" prüfen will, braucht arr.length > 0 && arr.every(...).

Short-Circuit beim ersten falsy

every hört auf zu iterieren, sobald ein Element falsy liefert. Im Schnitt also schneller als filter oder map, die das ganze Array durchlaufen. Bei großen Arrays spürbar.

every und some sind via De Morgan komplementär

every(p) ≡ !some(x => !p(x)). Praktisch: wer „kein Element erfüllt" prüfen will, schreibt !arr.some(p) — kürzer als arr.every(x => !p(x)).

Predicate kann jeden truthy/falsy-Wert zurückgeben

arr.every(x => x.valid) testet jede Property — kein expliziter === true nötig. Truthy reicht.

Sparse Arrays — Löcher werden übersprungen

[2, , 4].every(n => n > 0) liefert true, obwohl die Lücke nicht „> 0" ist. Der Predicate wird für Löcher gar nicht aufgerufen. In modernem Code irrelevant.

Type-Predicate in TypeScript für Narrowing

arr.every(isFoo) mit isFoo als Type-Guard verfeinert in TypeScript den Typ von arr von unknown[] auf Foo[]. Pure JavaScript bekommt davon nichts mit.

Im Gegensatz zu reduce — keine Akkumulator-State

every hat keinen Akkumulator. Wenn man parallel zur Predicate-Prüfung Werte sammeln will: reduce oder zwei separate Operations (every + filter).

every-Klassiker: assertEvery-Helper

Manche Codebases wickeln every in einen assertEvery(arr, p)-Helper, der bei false mit einer informativen Fehlermeldung wirft. Praktisch in Tests und API-Validierungen.

10 · Resources

Weiterführende Ressourcen

Externe Quellen

/ Weiter

Zurück zu Arrays

Zur Übersicht