Gestione degli errori

La gestione degli errori è uno degli aspetti più importanti nello sviluppo di qualsiasi applicazione. Un programma che controlla correttamente le situazioni impreviste risulta più stabile, affidabile e professionale.

La gestione degli errori nelle applicazioni.

Pubblicato il: 30-6-2026

Ultima Modifica: 30-6-2026

Introduzione

Ogni programma, anche il più semplice, può incontrare situazioni impreviste durante l'esecuzione. Un file potrebbe non esistere, una connessione di rete potrebbe interrompersi improvvisamente oppure l'utente potrebbe inserire dati non validi.

La capacità di gestire correttamente questi problemi distingue un'applicazione amatoriale da un software professionale. Una buona gestione degli errori permette infatti di evitare blocchi improvvisi, perdita di dati e comportamenti inattesi.

⚠️ Un errore non gestito può causare la chiusura immediata del programma.

Che cos'è un errore?

Un errore è una situazione che impedisce al programma di eseguire correttamente una determinata operazione.

Gli errori possono essere classificati in diverse categorie:

Errori di sintassi

Sono gli errori commessi durante la scrittura del codice sorgente.

Esempio in Pascal:

begin
  writeln('Ciao')

			end;

Manca il punto e virgola dopo writeln.

Questi errori vengono normalmente individuati dal compilatore.

Errori logici

Il programma viene compilato correttamente ma produce risultati errati.

Esempio:

Totale := Prezzo - Quantita;

Probabilmente il programmatore voleva scrivere:

Totale := Prezzo * Quantita;

🔍 Gli errori logici sono spesso i più difficili da individuare.

Errori di esecuzione

Si verificano durante il funzionamento del programma.

Alcuni esempi:

Apertura di un file inesistente.
Divisione per zero.
Mancanza di memoria disponibile.
Accesso a dati non validi.

Perché gestire gli errori?

Un'applicazione che ignora gli errori può:

❌ Bloccarsi improvvisamente.

❌ Perdere dati importanti.

❌ Mostrare messaggi incomprensibili.

❌ Offrire una pessima esperienza all'utente.

Una corretta gestione degli errori consente invece di:

✅ Evitare crash.

✅ Salvare i dati.

✅ Informare correttamente l'utente.

✅ Rendere il software più affidabile.

Controllare i dati inseriti dall'utente

Molti errori nascono da dati errati inseriti dall'utente.

Supponiamo di richiedere l'età:

if Eta < 0 then
begin
  
			writeln('Valore non valido');
end;

È sempre consigliabile verificare i dati prima di elaborarli.

🛡️ Mai dare per scontato che l'utente inserisca informazioni corrette.

Gestione degli errori nei file

L'apertura di un file rappresenta una delle operazioni più soggette a problemi.

Esempio in Pascal:

var
  F: TextFile;


			begin
  AssignFile(F, 'dati.txt');
  Reset(F);

			end;

Se il file non esiste il programma potrebbe interrompersi.

Una soluzione consiste nell'utilizzare il controllo degli errori I/O.

var
  F: TextFile;


			begin
  AssignFile(F, 'dati.txt');

  {$I-}
  
			Reset(F);
  {$I+}

  if IOResult <> 0 then
    
			writeln('Errore nell''apertura del file');
end;

📁 In questo modo il programma continua a funzionare anche in presenza dell'errore.

Utilizzo delle eccezioni

Nei linguaggi moderni viene spesso utilizzato il meccanismo delle eccezioni.

In Lazarus e Free Pascal possiamo utilizzare il blocco:

try
  // codice che può 
			generare errori
except
  on E: Exception do
    
			ShowMessage(E.Message);
end;

Esempio pratico:

uses
  SysUtils;

var
  
			N1, N2, Risultato: Integer;

begin
  try
    
			N1 := 100;
    N2 := 0;

    
			Risultato := N1 div N2;

    
			writeln(Risultato);
  except
    on E: 
			Exception do
      writeln('Errore: ', 
			E.Message);
  end;
end.

⚡ L'applicazione intercetta l'errore e mostra un messaggio invece di terminare in modo anomalo.

Gestione degli errori nei database

Quando si lavora con database possono verificarsi molti problemi:

Connessione assente.
Query errata.
Tabelle inesistenti.
Permessi insufficienti.

Esempio:

try
  Query.Open;
except
  
			on E: Exception do
    ShowMessage('Errore 
			database: ' + E.Message);
end;

Questo approccio permette di individuare rapidamente eventuali problemi.

🗄️ Una gestione accurata degli errori è fondamentale nelle applicazioni gestionali.

Registrare gli errori in un file di log

Molte applicazioni professionali salvano gli errori in appositi file di log.

Esempio:

procedure ScriviLog(Messaggio: 
			String);
var
  F: TextFile;
begin
  
			AssignFile(F, 'errori.log');

  if 
			FileExists('errori.log') then
    Append(F)
  
			else
    Rewrite(F);

  Writeln(F, 
			DateTimeToStr(Now) + ' - ' + Messaggio);

  CloseFile(F);

			end;

In caso di errore:

ScriviLog('Impossibile aprire il 
			database');

📝 I log rappresentano uno strumento prezioso per diagnosticare problemi segnalati dagli utenti.

Mostrare messaggi comprensibili

Un errore tecnico spesso non è utile all'utente finale.

Messaggio poco utile:

Exception EAccessViolation at address 004A56B2

Messaggio migliore:

Impossibile aprire il file richiesto.
Verificare che il file esista e riprovare.

😊 Un messaggio chiaro riduce confusione e richieste di assistenza.

Evitare di ignorare gli errori

Uno degli errori più comuni dei programmatori principianti consiste nel catturare le eccezioni senza fare nulla.

Esempio da evitare:

try
  OperazionePericolosa;

			except
end;

In questo caso l'errore viene nascosto e potrebbe risultare impossibile capire cosa sia accaduto.

Meglio almeno registrarlo:

try
  OperazionePericolosa;

			except
  on E: Exception do
    
			ScriviLog(E.Message);
end;

Buone pratiche

✔ Verificare sempre i dati ricevuti.

✔ Gestire gli errori di file e database.

✔ Utilizzare le eccezioni quando disponibili.

✔ Registrare gli errori nei log.

✔ Mostrare messaggi chiari agli utenti.

✔ Non ignorare mai gli errori.

✔ Testare attentamente tutte le situazioni anomale.

Conclusioni

Investire tempo nella gestione degli errori significa ridurre i malfunzionamenti, semplificare la manutenzione del software e migliorare notevolmente l'esperienza degli utenti. In altre parole, un buon programmatore non si limita a scrivere codice che funziona, ma scrive codice capace di reagire correttamente anche quando qualcosa va storto.