Nessun risultato. Prova con un altro termine.
Guide
Notizie
Software
Tutorial
  • Lezione 47 di 112
  • livello avanzato
Indice lezioni

Gestione delle eccezioni

Gestire gli errori a runtime grazie al costrutto try/catch. Intercettare le eccezioni, riconoscerle, crearne di nuove e orientare le reazioni del programma.
Gestire gli errori a runtime grazie al costrutto try/catch. Intercettare le eccezioni, riconoscerle, crearne di nuove e orientare le reazioni del programma.
Link copiato negli appunti

La gestione degli errori a runtime è un aspetto molto importante della programmazione, anche se spesso viene trascurato. Intercettare e gestire opportunamente eventuali malfunzionamenti durante l'esecuzione di un programma o di uno script è fondamentale per consentire, per quanto possibile, la prosecuzione dell'esecuzione o quanto meno per dare informazioni adeguate all'utente.

Le eccezioni

Un'eccezione è un errore che si verifica a runtime dovuto ad un'operazione non consentita. Esempi di situazioni che generano un'eccezione sono il riferimento ad una variabile non definita o la chiamata ad un metodo non esistente.

Non rientrano tra le eccezioni gli errori derivanti da sintassi non corretta, come ad esempio la mancata chiusura di una parentesi o dei doppi apici in una stringa.

try, catch

In JavaScript possiamo ricorrere al costrutto try...catch la cui funzionalità è del tutto analoga a quella degli omonimi costrutti di altri linguaggi di programmazione orientata agli oggetti.

Tramite questo costrutto siamo in grado di intercettare eccezioni e di definire un'opportuna strategia di gestione. Lo schema generale del costrutto try..catch è il seguente:

try {
	// Blocco di codice
} catch(e) {
	// Gestione dell'eccezione
}

L'istruzione try pone sotto controllo il blocco di codice associato. Se il blocco di codice viene eseguito correttamente, il controllo passa all'istruzione successiva al blocco catch.

Se si verifica un'eccezione, il controllo passa al blocco associato all'istruzione catch. Al verificarsi dell'eccezione il sistema genera un oggetto contenente informazioni sul problema riscontrato, in modo da poter essere analizzato all'interno del blocco di codice incaricato di gestire l'eccezione.

Ecco un esempio minimale di utilizzo di try..catch:

var x = 0;
try {
	func();
	x = x + 1;
} catch(e) {
	console.log(e.message);  // func is not defined
}
console.log(x);  //0

Dal momento che la funzione func() non è stata definita, la sua chiamata genererà un'eccezione che verrà catturata e gestita all'interno del blocco catch. La gestione che viene fatta dell'eccezione è abbastanza semplice in questo esempio: viene visualizzato il messaggio di sistema associato all'eccezione.

La differenza principale tra gestire e non gestire le eccezioni sta nel fatto che l'esecuzione dello script continua con l'istruzione che segue il blocco catch invece di terminare nel punto in cui si è verificata l'eccezione.

Tuttavia è importante ricordare che l'istruzione successiva alla chiamata a func(), che ha generato l'eccezione, non viene eseguita. Infatti il valore che verrà visualizzato dall'ultima istruzione sarà identico al valore iniziale della variabile x.

In altre parole, il verificarsi dell'eccezione interrompe l'esecuzione soltanto all'interno del blocco try, consentendo la prosecuzione dell'esecuzione al suo esterno.

Il costrutto try..catch prevede la clausola opzionale finally che consente di specificare un blocco di codice da eseguire in ogni caso, anche se si verificano eccezioni:

var x = 0;
try {
	func();
	x = x + 1;
} catch(e) {
	console.log(e.message);  // func is not defined
} finally {
	x = x - 1;
}
console.log(x);  // -1

In questo caso, dopo che si è verificata l'eccezione ed è stato visualizzato il messaggio d'errore, viene eseguito il blocco di codice associato a finally, ottenendo -1 come valore finale di x.

Anche se la funzione func() è definita e quindi non si verifica alcuna eccezione, il blocco finally viene sempre eseguito facendo assumere in questo caso alla variabile x il valore 0;

Proprietà delle eccezioni, riconoscere il tipo di errore

L'oggetto che rappresenta l'errore viene passato dal sistema come una sorta di parametro a catch. Esso prevede fondamentalmente due proprietà: name, che identifica il tipo di eccezione, e message, che indica il messaggio specifico dell'eccezione verificatasi. Eventuali proprietà aggiuntive possono essere presenti in base allo specifico engine JavaScript.

La possibilità di individuare il tipo di errore tramite name ci consente di gestire diversamente le situazioni di errore, come mostrato dal seguente esempio:

try {
	//Blocco di codice
} catch(e) {
	switch (e.name) {
		case "ReferenceError":
			console.log("Variabile o funzione non definita");
			break;
		case "TypeError":
			console.log("Non è stato utilizzato il tipo di dato previsto");
			break;
		...
	}
}

Generare eccezioni: throw

Infine, abbiamo la possibilità di generare eccezioni da programma tramite l'istruzione throw in modo da avere una gestione uniforme degli errori. Nel seguente esempio generiamo un'eccezione se una stringa non rappresenta un indirizzo di e-mail valido:

function convalidaEmail(value) {
	var emailRegExp = /\w+@\w+\.\w{2,4}/i;
	if (emailRegExp.test(value)) {
		return true;
	} else {
		throw new Error("Email non valida!");
	}
}


Ti consigliamo anche