Tipi di errore

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 Adobe Flash Player 9. Nella maggior parte dei casi è possibile gestirli man mano che si incontrano, 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 richiama una funzione, ad esempio, quando si prova a utilizzare un particolare metodo passando un argomento non valido. In questo caso, Flash Player 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("http://www.yourdomain.com/fileupload.cfm");
}
catch (error:IllegalOperationError)
{
    trace(error);
    // Error #2037: Funzioni chiamate in sequenza errata oppure la
    // chiamata precedente non è andata a buon fine.
}

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, vedere Gestione degli errori sincroni delle applicazioni.

Gli errori asincroni sono errori in fase di runtime che si verificano in momenti diversi dell'esecuzione e che generano eventi rilevati da listener di eventi. In un'operazione asincrona, una funzione avvia un'operazione senza attenderne il completamento. Si può creare un listener di eventi errore che attenda una reazione da parte dell'applicazione o dell'utente e, se l'operazione non va a buon fine, si rileva l'errore mediante il listener e si risponde 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 si esegue 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, è necessario usare il metodo addEventListener() per intercettare questi eventi specifici, come illustra il 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.url);
}
function openHandler(event:Event):void
{
    trace("...open...");
}
function completeHandler(event:Event):void
{
    trace("...complete...");
}

Per informazioni dettagliate sulla gestione degli errori asincroni, vedere 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 attuale né al superiore, l'errore viene considerato un'eccezione non rilevata.

In fase di runtime, Flash Player ignora intenzionalmente gli errori non rilevati e, se può, continua a riprodurre il file SWF perché gli utenti non possono necessariamente essere in grado di risolvere l'errore. Un errore non rilevato che passa sotto silenzio, cioè che viene ignorato, complica il lavoro delle applicazioni di debug. La versione debugger di Flash Player risponde agli errori non rilevati terminando lo script corrente e visualizzando l'errore non rilevato nell'istruzione trace o annotando il messaggio di errore nel file di registro. Se l'oggetto eccezione è un'istanza della classe Error o di una sua sottoclasse, viene richiamato il metodo getStackTrace() e le informazioni sulla traccia di stack vengono visualizzate anche nell'output dell'istruzione trace o nel file di registro. Per ulteriori informazioni sull'utilizzo della versione debugger di Flash Player, vedere Utilizzo della versione debugger di Flash Player.

Flash CS3

Pagina corrente: http://livedocs.adobe.com/flash/9.0_it/main/00000097.html