04.09 Some a every

Výuka

Proč Some a every?

some() a every() jsou metody pro testování prvků pole. some() ověřuje, zda alespoň jeden prvek splňuje podmínku. every() ověřuje, zda všechny prvky splňují podmínku.

Proč to potřebujeme?

• Validace dat - Zkontroluj, zda všichni uživatelé jsou dospělí
• Podmíněné větvení - Pokud existuje chyba, zobraz varování
• Optimalizace - Zastaví se po prvním nálezu (neprochází celé pole)
• Čitelnost - Místo smyčky s flagy použiješ jasnou metodu

Představ si to jako: Kontrola vstupenek na koncert. every() ověřuje "Mají všichni vstupenku?". some() ověřuje "Má alespoň někdo VIP vstupenku?".

Jak to funguje?

some(predicate):
1. Volá predikát pro každý prvek (zleva doprava)
2. Vrátí TRUE, pokud ALESPOŇ JEDEN prvek vyhovuje
3. Vrátí FALSE, pokud ŽÁDNÝ prvek nevyhovuje
4. Zastaví se po prvním true (optimalizace)

every(predicate):
1. Volá predikát pro každý prvek (zleva doprava)
2. Vrátí TRUE, pokud VŠECHNY prvky vyhovují
3. Vrátí FALSE, pokud ALESPOŇ JEDEN prvek nevyhovuje
4. Zastaví se po prvním false (optimalizace)

Klíčové koncepty

• some(predicate) - vrací true, pokud alespoň jeden prvek splňuje podmínku
• every(predicate) - vrací true, pokud všechny prvky splňují podmínku
• Predikát - funkce: (element, index, array) => boolean
• Early exit - obě metody se zastaví po rozhodnutí (neprochází zbytečně celé pole)
• Prázdné pole - some([]) = false, every([]) = true (vacuously true)
• Negace - !some() je ekvivalent every(!...), !every() je some(!...)

JavaScript

Příklad 1: some() - existuje alespoň jedno sudé číslo?

const numbers = [1, 3, 5, 8, 9];

const hasEven = numbers.some(function(num) {
  return num % 2 === 0;
});

console.log(hasEven);
// → true (8 je sudé)

// Pole bez sudých čísel
const oddOnly = [1, 3, 5, 7];
const hasEven2 = oddOnly.some(num => num % 2 === 0);
console.log(hasEven2);
// → false (žádné sudé číslo)

Co se stalo?

• some() prochází pole a hledá první prvek, kde predikát vrátí true
• Zastaví se po nálezu (neprochází celé pole)
• Vrací true, pokud alespoň jeden prvek vyhovuje
• Vrací false, pokud žádný prvek nevyhovuje

Příklad 2: every() - jsou všechna čísla sudá?

const numbers = [2, 4, 6, 8];

const allEven = numbers.every(num => num % 2 === 0);
console.log(allEven);
// → true (všechna jsou sudá)

// Pole se smíšenými čísly
const mixed = [2, 4, 5, 8];
const allEven2 = mixed.every(num => num % 2 === 0);
console.log(allEven2);
// → false (5 není sudé)

Co se stalo?

• every() prochází pole a kontroluje, zda všechny prvky vyhovují
• Zastaví se po prvním false (5 není sudé → konec)
• Vrací true, pokud všechny prvky vyhovují
• Vrací false, pokud alespoň jeden prvek nevyhovuje

Příklad 3: some() a every() s objekty

const users = [
  { name: 'Alice', age: 25, admin: false },
  { name: 'Bob', age: 17, admin: false },
  { name: 'Charlie', age: 30, admin: true }
];

// Existuje alespoň jeden admin?
const hasAdmin = users.some(user => user.admin);
console.log(hasAdmin);
// → true (Charlie je admin)

// Jsou všichni dospělí (18+)?
const allAdults = users.every(user => user.age >= 18);
console.log(allAdults);
// → false (Bob má 17)

// Existuje někdo starší než 40?
const hasOver40 = users.some(user => user.age > 40);
console.log(hasOver40);
// → false (nikdo není starší než 40)

// Mají všichni jméno (ne prázdný string)?
const allHaveNames = users.every(user => user.name.length > 0);
console.log(allHaveNames);
// → true (všichni mají jméno)

Co se stalo?

• Můžeš testovat jakoukoliv vlastnost objektu
• some() - "existuje alespoň jeden..."
• every() - "všichni..."

Příklad 4: Early exit - optimalizace

const numbers = [1, 2, 3, 4, 5];

// some se zastaví po nálezu
const result1 = numbers.some((num, index) => {
  console.log(`Checking index ${index}`);
  return num > 2;
});
// → Checking index 0
// → Checking index 1
// → Checking index 2
// → (zastaví se - 3 > 2 je true)
console.log(result1);  // → true

// every se zastaví po prvním false
const result2 = numbers.every((num, index) => {
  console.log(`Checking index ${index}`);
  return num < 3;
});
// → Checking index 0
// → Checking index 1
// → Checking index 2
// → (zastaví se - 3 není < 3)
console.log(result2);  // → false

Co se stalo?

• Optimalizace: Obě metody se zastaví, jakmile znají odpověď
• some() se zastaví po prvním true
• every() se zastaví po prvním false
• Neprochází zbytečně celé pole

Příklad 5: Prázdné pole - speciální případy

const empty = [];

console.log(empty.some(x => true));
// → false (žádný prvek neexistuje)

console.log(empty.every(x => true));
// → true (vacuously true - "všech 0 prvků splňuje podmínku")

console.log(empty.every(x => false));
// → true (stále vacuously true!)

Co se stalo?

• some([]) = false - žádný prvek neexistuje, takže nemůže splňovat podmínku
• every([]) = true - vacuously true (matematická konvence: prázdná množina splňuje všechny podmínky)
• Pozor: every na prázdném poli vždy vrátí true!

Příklad 6: Negace - vztah mezi some a every

const numbers = [1, 2, 3, 4, 5];

// "Existuje alespoň jeden prvek > 3?"
const hasGreater3 = numbers.some(n => n > 3);
console.log(hasGreater3);
// → true

// "Všechny prvky jsou <= 3?"
const allLessOrEqual3 = numbers.every(n => n <= 3);
console.log(allLessOrEqual3);
// → false (některé jsou > 3)

// Negace: !some(x) === every(!x)
console.log(!numbers.some(n => n > 3) === numbers.every(n => n <= 3));
// → true (ekvivalentní)

// Negace: !every(x) === some(!x)
console.log(!numbers.every(n => n > 3) === numbers.some(n => n <= 3));
// → true (ekvivalentní)

Co se stalo?

• De Morgan's laws pro pole:
  • !some(condition) = every(!condition)
  • !every(condition) = some(!condition)
• Můžeš přepsat negaci some na every a naopak

TypeScript

TypeScript přidává typovou kontrolu predikátu a type guards.

Stejné příklady s typy

// some a every s typy
const numbers: number[] = [1, 2, 3, 4, 5];
const hasEven: boolean = numbers.some(num => num % 2 === 0);
const allEven: boolean = numbers.every(num => num % 2 === 0);

// S objekty
interface User {
  name: string;
  age: number;
  admin: boolean;
}

const users: User[] = [
  { name: 'Alice', age: 25, admin: false },
  { name: 'Bob', age: 30, admin: true }
];

const hasAdmin: boolean = users.some(user => user.admin);
const allAdults: boolean = users.every(user => user.age >= 18);

// Type guard - zúžení typu
type Item = string | number;
const mixed: Item[] = [1, 'a', 2, 'b'];

function isString(x: Item): x is string {
  return typeof x === 'string';
}

const hasString: boolean = mixed.some(isString);
const allStrings: boolean = mixed.every(isString);

// Predikát s explicitními typy
const result: boolean = numbers.some((num: number, index: number, arr: number[]): boolean => {
  return num > 3;
});

// Chybová kontrola - predikát musí vracet boolean
const invalid = numbers.some(n => n);  // ⚠️ Funguje (truthy), ale lépe explicitně boolean
const valid = numbers.some(n => n > 0);  // ✅ Explicitně boolean

TypeScript přidává:

• ✅ Typovou kontrolu predikátu - musí vracet boolean (nebo truthy hodnotu)
• ✅ Inference - TypeScript pozná typ prvku automaticky
• ✅ Type guards - můžeš použít x is T pro zúžení typu
• ✅ Prevenci chyb - chyby odhalíš při psaní

Rozdíl JS vs TS

JavaScript:

• some/every fungují bez typové kontroly
• Predikát může vracet cokoliv (truthy/falsy)
• Flexibilnější, ale nebezpečnější

TypeScript:

• Predikát je typově kontrolovaný
• Lépe dokumentované záměry
• Bezpečnější, prevence chyb

// JavaScript - projde, ale matoucí
const numbers = [1, 2, 3];
const result = numbers.some(n => n);  // Vrací truthy hodnotu, ne boolean

// TypeScript - funguje, ale lépe explicitně
const result: boolean = numbers.some(n => n > 0);  // Jasný záměr

Tip

💡 some/every místo manuálních smyček:

// ❌ Těžko čitelné - manuální flag
let hasEven = false;
for (let i = 0; i < numbers.length; i++) {
  if (numbers[i] % 2 === 0) {
    hasEven = true;
    break;
  }
}

// ✅ Čitelné - použij some
const hasEven = numbers.some(n => n % 2 === 0);

💡 Využij early exit pro výkon:

// ✅ Efektivní - zastaví se po prvním nálezu
const hasExpensiveCondition = numbers.some(n => expensiveCheck(n));

// ❌ Neefektivní - prochází celé pole
const hasExpensiveCondition = numbers.filter(n => expensiveCheck(n)).length > 0;

💡 Pozor na prázdné pole:

const empty = [];

console.log(empty.some(x => false));  // → false (OK)
console.log(empty.every(x => false)); // → true (POZOR! Vacuously true)

// ✅ Kontroluj délku, pokud to záleží
if (arr.length > 0 && arr.every(x => x > 0)) {
  console.log('Všechny prvky jsou kladné');
}