Olika typer av fel

Flash Player 9 och senare, Adobe AIR 1.0 och senare

När du utvecklar och kör program kommer du att upptäcka olika typer av fel och felterminologi. I listan beskrivs de vanligaste feltyperna och begreppen:

Kompileringsfel inträffar när ett fel upptäcks under kompileringen i ActionScript-kompilatorn. Kompileringsfel visas när syntaktiska problem i koden förhindrar att programmet skapas.
Körningsfel inträffar när du kör programmet efter kompileringen. Körningsfel är fel som inträffar när en SWF-fil spelas i Flash-miljön (till exempel Adobe Flash Player eller Adobe AIR). I de flesta fall hanterar du körningsfel när de inträffar, rapporterar dem till användaren och vidtar de åtgärder som krävs för att programmet ska kunna fortsätta att köras. Om ett allvarligt fel inträffar, om det till exempel inte går att ansluta till en fjärrwebbplats eller läsa in nödvändiga data, kan du använda felhantering för att se till att programmet stängs på ett bra sätt.
Synkrona fel är körningsfel som inträffar när en funktion anropas, till exempel om du använder en viss metod och det argument som skickas till metoden är ogiltigt och således genererar ett undantag. De flesta felen är synkrona, när programsatsen körs, och flödeskontrollen överförs omedelbart till den lämpligaste catch -satsen.

Följande exempel kommer att resultera i ett körningsfel eftersom metoden browse() inte anropas innan ett försök görs att hämta en fil:
```
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. 
}
```
I detta fall inträffar ett körningsfel synkront eftersom det i Flash Player upptäcks att metoden browse() inte anropades innan hämtningsförsöket gjordes.

Mer information om synkron felhantering finns i Hantera synkrona fel i ett program .
Asynkrona fel är körningsfel som inträffar utanför det normala programflödet. De skapar händelser och händelseavlyssnare fångar upp dem. En asynkron åtgärd är en åtgärd där en funktion initierar en åtgärd, men inte väntar på att den ska avslutas. Du kan skapa en felhändelseavlyssnare för att vänta på att programmet eller användaren ska utföra någon åtgärd. Om åtgärden misslyckas fångas felet upp av händelseavlyssnaren och felhändelsen besvaras. Därefter anropar händelseavlyssnaren en händelsehanterarfunktion för att besvara felhändelsen på ett verkningsfullt sätt. Händelsehanteraren kan öppna en dialogruta med information om hur användaren ska åtgärda det uppkomna felet.

Om du som i exemplet tidigare med det synkrona felet vid filhämtning. anropar metoden browse() innan du startar hämtningen kommer Flash Player att sända ut flera händelser. När exempelvis en hämtning startas skickas händelsen open . När hämtningsoperationen är avslutad skickas händelsen complete . Eftersom händelsehantering är asynkron (d.v.s. inte inträffar vid en speciell, känd och i förväg bestämd tidpunkt), ska du använda metoden addEventListener() för att avlyssna dessa specifika händelser, som exemplet nedan visar:
```
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..."); 
}
```
Mer information om asynkron felhantering finns i Svara på felhändelser och status .
Ej infångade undantag är fel som orsakas av att ingen motsvarande logik (som en catch-sats) besvarar felet. Om ett fel inträffar i programmet och ingen lämplig catch -sats eller händelsehanterare som kan hantera felet hittas på den aktuella nivån eller en högre nivå, kommer felet att betraktas som ett ej infångat undantag.

När ett fel som inte infångades inträffar skickas en uncaughtError -händelse. Den här händelsen kallas också för ”global felhanterare”. Händelsen skickas av SWF-filens UncaughtErrorEvents-objekt, som är tillgängligt via egenskapen LoaderInfo.uncaughtErrorEvents . Om inga avlyssnare har registrerats för uncaughtError -händelsen, ignorerar körningen dessa fel och försöker att fortsätta, så länge som felet inte stoppar SWF:en.

Förutom att skicka händelsen uncaughtError svarar Flash-körningens felsökningsversioner på fel som inte fångats in genom att avbryta det aktuella skriptet. Felet som inte fångats in visas sedan i en trace -sats eller i ett felmeddelandet i en loggfil. Om undantagsobjektet är en instans av Error-klassen eller dess underklasser visas även stackspårningsinformation i utdata. Mer information om hur du använder de olika felsökningsversionerna av Flash finns i Arbeta med felsökningsversioner av Flash-miljöer .

Obs! När en uncaughtError-händelse hanteras, och en error-händelse genereras från en uncaughtError-hanterare, anropas händelsehanteraren flera gånger. Detta ger upphov till en oändlig slinga med undantagsfel. Du bör undvika ett sådant scenario.