Tipi di errore

Flash Player 9 e versioni successive, Adobe AIR 1.0 e versioni successive

Durante lo sviluppo e l'esecuzione di applicazioni si incontrano diversi tipi di errore e vari termini relativi agli errori. Ecco un elenco dei principali tipi di errore e dei termini a essi relativi:

Gli errori in fase di compilazione vengono generati dal compilatore ActionScript durante la compilazione del codice e si verificano se sono presenti dei problemi di sintassi che impediscono la compilazione del codice.
Gli errori in fase di runtime si verificano durante l'esecuzione dell'applicazione già compilata e sono errori generati durante la riproduzione di un file SWF in un runtime Flash (ad esempio, Adobe Flash Player o Adobe AIR). Nella maggior parte dei casi potete gestire gli errori man mano che si verificano, comunicandoli all'utente e intervenendo in modo che l'applicazione non si interrompa. Se l'errore è irreversibile, ad esempio se non è possibile collegarsi a un sito Web remoto o caricare dei dati necessari, la gestione degli errori permette di interrompere l'applicazione normalmente.
Gli errori sincroni sono errori in fase di runtime che si verificano quando si chiama una funzione, ad esempio, quando provate a utilizzare un particolare metodo passando un argomento non valido. In questo caso, il runtime Flash genera un'eccezione. La maggior parte degli errori sono di tipo sincrono, cioè avvengono nel momento in cui l'istruzione viene eseguita, e il flusso di controllo passa immediatamente all'istruzione catch più adeguata.

La seguente porzione di codice, ad esempio, genera un errore runtime perché il metodo browse() non viene chiamato prima che il programma tenti di caricare un file:
```
var fileRef:FileReference = new FileReference(); 
try 
{ 
    fileRef.upload(new URLRequest("http://www.yourdomain.com/fileupload.cfm")); 
} 
catch (error:IllegalOperationError) 
{ 
    trace(error); 
    // Error #2037: Functions called in incorrect sequence, or earlier 
    // call was unsuccessful. 
}
```
In questo caso, l'errore in fase di runtime viene generato in modo sincrono perché Flash Player determina che il metodo browse() non è stato chiamato prima del tentativo di caricamento del file.

Per informazioni dettagliate sulla gestione degli errori sincroni, vedete Gestione degli errori sincroni delle applicazioni .
Gli errori asincroni sono errori runtime che si verificano al di fuori del normale flusso del programma. Generano eventi e sono rilevati dai listener di eventi. In un'operazione asincrona, una funzione avvia un'operazione senza attenderne il completamento. Potete creare un listener di eventi errore che attenda una reazione da parte dell'applicazione o dell'utente. Se l'operazione non va a buon fine, potete rilevare l'errore mediante il listener e rispondere all'errore. A questo punto, il listener di eventi chiama una funzione di gestione eventi che risponda all'errore in modo utile, per esempio visualizzando una finestra di dialogo con una richiesta di risolvere il problema diretta all'utente.

Consideriamo nuovamente l'esempio di errore sincrono presentato prima. Se eseguite una chiamata corretta al metodo browse() prima di avviare il caricamento del file, Flash Player invia vari eventi. Ad esempio, all'avvio del caricamento, viene inviato l'evento open. Quando l'operazione di caricamento del file viene completata correttamente, viene inviato l'evento complete. Poiché la gestione degli eventi è un'attività asincrona, cioè che non avviene in momenti prestabiliti e conosciuti, utilizzate il metodo addEventListener() per intercettare questi eventi specifici, come illustrato nel codice seguente:
```
var fileRef:FileReference = new FileReference(); 
fileRef.addEventListener(Event.SELECT, selectHandler); 
fileRef.addEventListener(Event.OPEN, openHandler); 
fileRef.addEventListener(Event.COMPLETE, completeHandler); 
fileRef.browse(); 
 
function selectHandler(event:Event):void 
{ 
    trace("...select..."); 
    var request:URLRequest = new URLRequest("http://www.yourdomain.com/fileupload.cfm"); 
    request.method = URLRequestMethod.POST; 
    event.target.upload(request); 
} 
function openHandler(event:Event):void 
{ 
    trace("...open..."); 
} 
function completeHandler(event:Event):void 
{ 
    trace("...complete..."); 
}
```
Per informazioni dettagliate sulla gestione degli errori asincroni, vedete Risposte a eventi errore e a errori basati sullo stato .
Le eccezioni non rilevate sono errori generati a cui non corrisponde una logica (come un'istruzione catch ) di risposta. Se l'applicazione genera un errore per il quale non esiste un'espressione catch appropriata o per il quale non è disponibile un gestore, né al livello corrente né al superiore, l'errore viene considerato un'eccezione non rilevata.

Quando si verifica un errore non rilevato, il runtime invia un evento uncaughtError , noto anche come “gestore di errori globale”, inviato dall'oggetto UncaughtErrorEvents del SWF, disponibile a sua volta tramite la proprietà LoaderInfo.uncaughtErrorEvents . Se per l'evento uncaughtError non è registrato nessun listener, il runtime ignora gli errori non rilevati e cerca di continuare l'esecuzione, purché l'errore non interrompa il file SWF.

Oltre a inviare l'evento uncaughtError , le versioni debugger del runtime Flash rispondono agli errori non rilevati terminando lo script corrente e visualizzando l'errore non rilevato nell'output dell'istruzione trace o annotando il messaggio di errore nel file di registro. Se l'oggetto eccezione è un'istanza della classe Error o di una delle sue sottoclassi, nell'output sono visualizzate anche le informazioni di traccia dello stack. Per ulteriori informazioni sull'utilizzo della versione debugger dei runtime Flash, vedete Utilizzo delle versioni debugger dei runtime Flash .

Nota: durante l'elaborazione di un evento uncaughtError, se un evento error viene generato da un gestore eventi uncaughtError, quest'ultimo verrà chiamato più volte. Questo determina un ciclo infinito di eccezioni. Si consiglia di evitare questa situazione.