Typen fouten

Flash Player 9 of hoger, Adobe AIR 1.0 of hoger

Bij het ontwikkelen en uitvoeren van toepassingen komt u verschillende soorten fouten en uiteenlopende terminologie tegen. De belangrijkste fouttypen en fouttermen worden hierna besproken:

Compilatiefouten worden door de ActionScript-compiler gegenereerd tijdens het compileren van de code. Compilatiefouten doen zich ook wanneer syntaxisproblemen in uw code het onmogelijk maken om de definitieve toepassing te maken.
Uitvoeringsfouten treden op wanneer u uw toepassing uitvoert na het compileren. Uitvoerfouten zijn fouten die optreden terwijl een SWF-bestand in een Flash runtime ( zoals Adobe Flash Player of Adobe AIR) wordt afgespeeld. Meestal handelt u uitvoeringsfouten direct af door deze aan de gebruiker te melden en stappen te nemen om de toepassing aan de gang te houden. Als de fout fataal is (er kan bijvoorbeeld geen verbinding met een externe website worden gemaakt of de benodigde gegevens kunnen niet worden geladen), kunt u foutafhandeling gebruiken om de toepassing netjes te laten afsluiten.
Synchrone fouten zijn uitvoerfouten die optreden op het moment dat een functie wordt aangeroepen, bijvoorbeeld wanneer u een specifieke methode probeert te gebruiken terwijl het aan de methode doorgegeven argument ongeldig is. Er wordt dan een uitzondering gegenereerd door de Flash-runtime. De meeste fouten zijn synchroon, dus bij het uitvoeren van een instructie, en het verloop wordt meteen doorgegeven aan de meest toepasselijke instructie van het type catch .

Het volgende codefragment bijvoorbeeld genereert een uitvoeringsfout omdat de methode browse() niet wordt aangeroepen voordat het programma probeert een bestand te uploaden:
```
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 dit geval wordt een synchrone uitvoeringsfout gegenereerd omdat Flash Player heeft vastgesteld dat de methode browse() niet is aangeroepen voordat werd geprobeerd het bestand te uploaden.

Zie Synchrone fouten in een toepassing afhandelen voor meer informatie over synchrone foutafhandeling.
Asynchrone fouten zijn runtimefouten die optreden buiten de normale programmastroom. Deze genereren gebeurtenissen en gebeurtenislisteners vangen deze af. Een asynchrone bewerking houdt in dat een functie een bewerking begint, maar niet wacht tot de bewerking klaar is. U kunt een listener voor een foutgebeurtenis maken die wacht tot de toepassing of gebruiker begint met een bewerking. Als deze bewerking mislukt, vangt u de fout af met een gebeurtenislistener en reageert u op de foutgebeurtenis. Vervolgens roept de gebeurtenislistener een gebeurtenishandlerfunctie aan om op een zinvolle manier op de foutgebeurtenis te reageren. De gebeurtenishandler kan bijvoorbeeld een dialoogvenster openen waarin de gebruiker wordt gevraagd de fout op te lossen.

Bekijk het eerder gegeven voorbeeld met de synchrone fout bij het uploaden van een bestand. Als u de methode browse() goed kunt aanroepen voordat u begint met het uploaden van een bestand, zou Flash Player verschillende gebeurtenissen verzenden. Bij het starten van de upload bijvoorbeeld wordt de gebeurtenis open verzonden. Wanneer het uploaden van het bestand goed is afgerond, wordt de gebeurtenis complete verzonden. Omdat gebeurtenisafhandeling asynchroon is (dat wil zeggen dat de afhandeling niet plaatsvindt op specifieke, bekende en vooraf bepaalde tijdstippen), moet u de methode addEventListener() gebruiken. Hierdoor wordt er geluisterd of deze specifieke gebeurtenissen plaatsvinden. Dit wordt in de volgende code getoond:
```
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..."); 
}
```
Zie Reageren op foutgebeurtenissen en een specifieke status voor meer informatie over asynchrone foutafhandeling.
Niet-afgevangen uitzonderingen zijn fouten die worden gegenereerd zonder bijbehorende logica (zoals een instructie catch ) om erop te reageren. Als uw toepassing een fout genereert en er is op het huidige of hogere niveau geen passende instructie van het type catch of gebeurtenishandler aanwezig om de fout af te handelen, wordt de fout beschouwd als een niet-afgevangen uitzondering.

Wanneer er een niet-afgevangen fout optreedt, wordt door de runtime de gebeurtenis uncaughtError verzonden. Deze gebeurtenis wordt ook wel een "globale fouthandler" genoemd. Deze gebeurtenis wordt verzonden door het object UncaughtErrorEvents van SWF, dat beschikbaar is via de eigenschap LoaderInfo.uncaughtErrorEvents . Als er geen listeners zijn geregistreerd voor de gebeurtenis uncaughtError , worden niet-afgevangen fouten tijdens runtime genegeerd. Zolang de fout SWF niet onderbreekt, wordt er doorgegaan met de uitvoering.

Bij niet-afgevangen fouten verzenden foutopsporingsversies van de Flash-runtime niet alleen de gebeurtenis uncaughtError , maar reageren ze ook door het huidige script te beëindigen.· Vervolgens wordt de niet-afgevangen fout weergegeven in de uitvoer van een trace -instructie of wordt het foutbericht naar een logbestand geschreven. Als het uitzonderingsobject een instantie van de Error-klasse of een van de subklassen ervan is, worden stacktracegegevens ook weergegeven in de uitvoer. Zie Werken met de foutopsporingsversies van Flash runtime voor meer informatie over het gebruik van de foutopsporingsversie van Flash Player.

Opmerking: Als tijdens de verwerking van een uncaughtError-gebeurtenis een foutgebeurtenis wordt gegenereerd door een uncaughtError-handler, wordt de gebeurtenishandler meerdere malen aangeroepen. Dit leidt tot een oneindige lus van uitzonderingen. U kunt een dergelijk scenario beter vermijden.