Ciclo Do-While

Il ciclo do-while in TypeScript rappresenta una struttura di controllo che garantisce l’esecuzione di almeno una iterazione del blocco di codice, poiché la condizione viene valutata dopo ogni esecuzione anziché prima. Questa caratteristica lo rende fondamentale per scenari dove è necessario eseguire un’operazione almeno una volta prima di decidere se continuare.

Sintassi e Comportamento

La struttura do-while inverte il controllo rispetto al while tradizionale, eseguendo prima il corpo del ciclo e poi valutando la condizione di continuazione.

do {
  // Blocco di codice eseguito almeno una volta
} while (condizione);

let count: number = 0;
do {
  console.log(`Count: ${count}`);
  count++;
} while (count < 3);
// Output: Count: 0, Count: 1, Count: 2

Pattern di Validazione

Il do-while è particolarmente efficace per validazione di input dove è necessario richiedere almeno un valore prima di verificarne la correttezza.

let userInput: string;
let isValid: boolean;

do {
  userInput = prompt("Enter your name:") || "";
  isValid = userInput.length > 0 && userInput.trim() !== "";

  if (!isValid) {
    console.log("Please enter a valid name");
  }
} while (!isValid);

Retry Pattern

Il do-while è ideale per implementare pattern di retry in operazioni che potrebbero fallire ma devono essere tentate almeno una volta.

interface ApiResponse {
  success: boolean;
  data?: any;
  error?: string;
}

async function fetchWithRetry(): Promise<any> {
  let attempts = 0;
  let response: ApiResponse;

  do {
    attempts++;
    response = await makeApiCall();

    if (!response.success) {
      console.log(`Attempt ${attempts} failed`);
    }
  } while (!response.success && attempts < 3);

  if (!response.success) {
    throw new Error("Max attempts reached");
  }

  return response.data;
}

Menu e Interfacce Utente

Il do-while è perfetto per implementare menu interattivi che devono essere mostrati almeno una volta.

type MenuOption = "view" | "create" | "edit" | "exit";

function showMenu(): void {
  let selectedOption: MenuOption;

  do {
    console.log("1. View\n2. Create\n3. Edit\n4. Exit");
    const input = prompt("Select option:") || "";

    switch (input) {
      case "1":
        selectedOption = "view";
        break;
      case "2":
        selectedOption = "create";
        break;
      case "3":
        selectedOption = "edit";
        break;
      case "4":
        selectedOption = "exit";
        break;
      default:
        selectedOption = "view"; // Force continue
    }

    if (selectedOption !== "exit") {
      executeAction(selectedOption);
    }
  } while (selectedOption !== "exit");
}

Differenze con While

La scelta tra do-while e while dipende dalla necessità di garantire almeno una esecuzione del blocco di codice.

let condition = false;

// While: può non eseguire mai il blocco
while (condition) {
  console.log("Never executed");
}

// Do-While: esegue sempre almeno una volta
do {
  console.log("Executed once"); // Questo viene stampato
} while (condition);

Controllo di Stato

Il do-while è utile per gestire stati che devono essere verificati almeno una volta.

enum ConnectionState {
  Disconnected,
  Connecting,
  Connected,
  Error,
}

class Connection {
  private state = ConnectionState.Disconnected;

  connect(): boolean {
    let attempts = 0;

    do {
      attempts++;
      this.state = ConnectionState.Connecting;

      const connected = this.attemptConnection();
      if (connected) {
        this.state = ConnectionState.Connected;
        return true;
      }

      this.state = ConnectionState.Error;
    } while (this.state !== ConnectionState.Connected && attempts < 3);

    return this.state === ConnectionState.Connected;
  }

  private attemptConnection(): boolean {
    return Math.random() > 0.5; // Simulazione
  }
}

Il ciclo do-while garantisce quindi l’esecuzione di almeno una iterazione, rendendolo ideale per scenari di validazione, retry pattern e interfacce utente dove un’azione deve essere eseguita prima di verificare le condizioni di continuazione.