2.6 While a do-while

Výuka

Kdy použít while místo for?

for je nejlepší, když víš předem, kolikrát se má cyklus opakovat (např. 10x, nebo pro každý prvek pole).

while je nejlepší, když nevíš předem, kolikrát se bude opakovat - cyklus běží, dokud platí podmínka.

Příklady použití while:

• Čtení uživatelského vstupu, dokud nezadá správnou hodnotu
• Čekání na odpověď serveru
• Zpracování dat, dokud nejsou vyčerpána
• Hry - herní smyčka běží, dokud hráč neprohraje

Anatomie while

while (podmínka) {
  // tělo - opakuje se, dokud je podmínka true
}

Pozor: Podmínka se kontroluje před každou iterací. Pokud je hned na začátku false, tělo se nikdy neprovede.

do...while - vždy alespoň jednou

do {
  // tělo - provede se ALESPOŇ JEDNOU
} while (podmínka);

Rozdíl: Podmínka se kontroluje po těle, takže tělo se vždy provede minimálně jednou.

JavaScript

// Základní while
let count = 0;

while (count < 5) {
  console.log(count);
  count++;
}
// 0, 1, 2, 3, 4

// While s neznámým počtem iterací
let number = 1;

while (number < 1000) {
  number *= 2;
  console.log(number);
}
// 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024

// Čtení vstupu (simulace)
let password = "";
let attempts = 0;

while (password !== "secret" && attempts < 3) {
  password = prompt("Zadej heslo:");  // simulace
  attempts++;
}

if (password === "secret") {
  console.log("Přístup povolen");
} else {
  console.log("Příliš mnoho pokusů");
}

// do...while - vždy alespoň jednou
let input;

do {
  input = prompt("Zadej číslo větší než 10:");
} while (input <= 10);

console.log(`Zadal jsi: ${input}`);

// Rozdíl while vs do...while
let x = 10;

while (x < 5) {
  console.log("while:", x);  // NIKDY se neprovede
  x++;
}

let y = 10;

do {
  console.log("do-while:", y);  // Provede se JEDNOU
  y++;
} while (y < 5);

// Procházení pole s while (ne moc běžné)
const fruits = ["jablko", "banán", "třešeň"];
let i = 0;

while (i < fruits.length) {
  console.log(fruits[i]);
  i++;
}

// Hledání v poli
const numbers = [4, 7, 2, 9, 1, 5];
let index = 0;

while (index < numbers.length && numbers[index] !== 9) {
  index++;
}

console.log(`Číslo 9 nalezeno na indexu: ${index}`);

// Generování náhodných čísel, dokud nepadne 6
let dice;
let rolls = 0;

do {
  dice = Math.floor(Math.random() * 6) + 1;
  rolls++;
  console.log(`Hod ${rolls}: ${dice}`);
} while (dice !== 6);

console.log(`Padla 6 po ${rolls} hodech`);

TypeScript

// Typovaný while
let count: number = 0;

while (count < 5) {
  console.log(count);
  count++;
}

// Funkce s while
function findFirstNegative(numbers: number[]): number | undefined {
  let i = 0;

  while (i < numbers.length) {
    if (numbers[i] < 0) {
      return numbers[i];
    }
    i++;
  }

  return undefined;
}

const result = findFirstNegative([1, 2, -3, 4]);
console.log(result);  // -3

// do...while s typy
function getValidInput(): number {
  let input: number;

  do {
    const raw = prompt("Zadej kladné číslo:");
    input = Number(raw);
  } while (isNaN(input) || input <= 0);

  return input;
}

// Iterator pattern
interface Iterator<T> {
  hasNext(): boolean;
  next(): T;
}

function processAll<T>(iterator: Iterator<T>): T[] {
  const results: T[] = [];

  while (iterator.hasNext()) {
    results.push(iterator.next());
  }

  return results;
}

// Async while (simulace)
async function pollUntilReady(checkFn: () => Promise<boolean>): Promise<void> {
  let ready = false;

  while (!ready) {
    ready = await checkFn();
    if (!ready) {
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }
}

// Narrowing v while
function processQueue(queue: (string | null)[]): void {
  let item = queue.shift();

  while (item !== null && item !== undefined) {
    // TypeScript ví, že item je string
    console.log(item.toUpperCase());
    item = queue.shift();
  }
}

Rozdíl JS vs TS

// TypeScript pomáhá s kontrolou
let count: number = 0;

while (count < "5") {  // ❌ Error: nelze porovnat number a string
  count++;
}

// Správně
while (count < 5) {
  count++;
}

Tip

💡 Vždy zajisti, že se podmínka změní:

// ❌ NEKONEČNÝ CYKLUS!
let i = 0;
while (i < 10) {
  console.log(i);
  // Zapomněl jsem i++!
}

// ✅ Správně
let i = 0;
while (i < 10) {
  console.log(i);
  i++;  // Podmínka se změní
}

💡 Používej do...while pro validaci vstupu:

// ✅ Vždy se zeptá alespoň jednou
let age;
do {
  age = parseInt(prompt("Zadej věk (1-120):"));
} while (isNaN(age) || age < 1 || age > 120);

💡 Přidej maximální počet iterací jako pojistku:

// ✅ Pojistka proti nekonečné smyčce
let attempts = 0;
const MAX_ATTEMPTS = 1000;

while (condition && attempts < MAX_ATTEMPTS) {
  // ...
  attempts++;
}

if (attempts >= MAX_ATTEMPTS) {
  console.error("Příliš mnoho pokusů");
}

💡 while (true) s break je validní pattern:

while (true) {
  const input = getUserInput();

  if (input === "quit") {
    break;  // Ukončí cyklus
  }

  processInput(input);
}