Esercizi Eccezioni JavaScript

Codegrind Team•Jul 12 2024

Ecco degli esercizi con soluzione per praticare la gestione delle eccezioni in JavaScript.

Esercizio 1: Try-Catch Semplice

Utilizzare `try` e `catch` per gestire un'eccezione lanciata da una divisione per zero.

function dividi(a, b) {
  try {
    if (b === 0) {
      throw new Error("Divisione per zero non permessa");
    }
    return a / b;
  } catch (e) {
    console.error(e.message);
  }
}

console.log(dividi(10, 2)); // 5
console.log(dividi(10, 0)); // Divisione per zero non permessa

Esercizio 2: Try-Catch-Finally

Utilizzare `try`, `catch` e `finally` per gestire un'eccezione e garantire l'esecuzione di un blocco di codice finale.

function leggiFile(file) {
  try {
    // Simula la lettura di un file
    if (file === "") {
      throw new Error("File non trovato");
    }
    console.log("Contenuto del file: ...");
  } catch (e) {
    console.error(e.message);
  } finally {
    console.log("Operazione di lettura terminata");
  }
}

leggiFile("documento.txt"); // Contenuto del file: ... Operazione di lettura terminata
leggiFile(""); // File non trovato Operazione di lettura terminata

Esercizio 3: Lanciare un’eccezione personalizzata

Creare e lanciare un'eccezione personalizzata per gestire un errore specifico.

class InvalidInputError extends Error {
  constructor(message) {
    super(message);
    this.name = "InvalidInputError";
  }
}

function validaInput(input) {
  try {
    if (typeof input !== "string") {
      throw new InvalidInputError("Input non valido: deve essere una stringa");
    }
    console.log("Input valido");
  } catch (e) {
    console.error(`${e.name}: ${e.message}`);
  }
}

validaInput("test"); // Input valido
validaInput(123); // InvalidInputError: Input non valido: deve essere una stringa

Esercizio 4: Rilanciare un’eccezione

Gestire un'eccezione e poi rilanciarla per una gestione successiva.

function processaDato(dato) {
  try {
    if (dato < 0) {
      throw new Error("Dato negativo non permesso");
    }
    console.log("Dato processato:", dato);
  } catch (e) {
    console.error("Errore in processaDato:", e.message);
    throw e; // Rilancia l'eccezione
  }
}

function esegui() {
  try {
    processaDato(-1);
  } catch (e) {
    console.error("Errore in esegui:", e.message);
  }
}

esegui(); // Errore in processaDato: Dato negativo non permesso Errore in esegui: Dato negativo non permesso

Esercizio 5: Gestione di più eccezioni

Gestire diverse eccezioni con messaggi specifici per ciascuna.

function calcola(a, b, operazione) {
  try {
    if (typeof a !== "number" || typeof b !== "number") {
      throw new TypeError("Entrambi gli argomenti devono essere numeri");
    }
    if (operazione === "dividi" && b === 0) {
      throw new RangeError("Divisione per zero non permessa");
    }
    switch (operazione) {
      case "somma":
        return a + b;
      case "sottrai":
        return a - b;
      case "moltiplica":
        return a * b;
      case "dividi":
        return a / b;
      default:
        throw new Error("Operazione non valida");
    }
  } catch (e) {
    console.error(`${e.name}: ${e.message}`);
  }
}

console.log(calcola(10, 2, "somma")); // 12
console.log(calcola(10, 2, "dividi")); // 5
console.log(calcola(10, 0, "dividi")); // RangeError: Divisione per zero non permessa
console.log(calcola(10, "due", "somma")); // TypeError: Entrambi gli argomenti devono essere numeri
console.log(calcola(10, 2, "sbagliato")); // Error: Operazione non valida

Esercizio 6: Eccezioni annidate

Gestire eccezioni annidate all'interno di più blocchi `try`.

function operazioneComplessa(dato) {
  try {
    try {
      if (dato === null) {
        throw new Error("Dato nullo non permesso");
      }
      console.log("Dato processato:", dato);
    } catch (e) {
      console.error("Errore interno:", e.message);
      throw new Error("Errore nel processo interno");
    }
  } catch (e) {
    console.error("Errore esterno:", e.message);
  }
}

operazioneComplessa(null); // Errore interno: Dato nullo non permesso Errore esterno: Errore nel processo interno
operazioneComplessa(42); // Dato processato: 42

Esercizio 7: Validazione di input

Utilizzare le eccezioni per validare l'input di una funzione.

function validaInput(nome, eta) {
  try {
    if (typeof nome !== "string" || nome.length === 0) {
      throw new Error("Nome non valido");
    }
    if (typeof eta !== "number" || eta <= 0) {
      throw new Error("Età non valida");
    }
    console.log(`Nome: ${nome}, Età: ${eta}`);
  } catch (e) {
    console.error(e.message);
  }
}

validaInput("Mario", 30); // Nome: Mario, Età: 30
validaInput("", 30); // Nome non valido
validaInput("Mario", -5); // Età non valida

Esercizio 8: Log delle eccezioni

Creare una funzione che logga le eccezioni in un array per un successivo debugging.

const logErrori = [];

function loggaEccezione(eccezione) {
  logErrori.push(eccezione.message);
}

function operazione(dato) {
  try {
    if (dato < 0) {
      throw new Error("Dato negativo non permesso");
    }
    console.log("Dato processato:", dato);
  } catch (e) {
    console.error(e.message);
    loggaEccezione(e);
  }
}

operazione(10); // Dato processato: 10
operazione(-1); // Dato negativo non permesso

console.log(logErrori); // ["Dato negativo non permesso"]