Hantera synkrona fel i ett program

När du arbetar med synkrona körningsfel ska du använda try..catch..finally-satser för att fånga upp fel. När ett körningsfel inträffar genererar Flash-miljön ett undantag, vilket betyder att programmet upphör att köras normalt och ett specialobjekt av typen Error skapas. Objektet Error skickas sedan till det första tillgängliga catch-blocket.

Programsatsen try omsluter programsatser där fel kan uppstå. Du använder alltid programsatsen catch med en try-sats. Om ett fel upptäcks i någon av programsatserna i programsatsblocket try kommer den catch-sats som är kopplad till programsatsen try att köras.

Programsatsen finally omfattar programsatser som körs om ett fel inträffar i blocket try. Om det inte finns något fel kommer de programsatser som finns i blocket finally att köras när blockprogramsatsen try är avslutad. Om det finns ett fel kommer rätt catch-sats att köras först, följd av programsatserna i blocket finally.

Med följande kod demonstreras syntaxen som används för try..catch..finally-satser:

try 
{ 
    // some code that could throw an error 
} 
catch (err:Error) 
{ 
    // code to react to the error 
} 
finally 
{ 
    // Code that runs whether an error was thrown. This code can clean 
    // up after the error, or take steps to keep the application running. 
}

Varje catch-sats identifierar en specifik typ av undantag som den hanterar. Programsatsen catch kan endast ange felklasser som är underklasser till klassen Error. Varje catch-sats kontrolleras i rätt ordning. Endast den första catch-satsen som överensstämmer med det aktuella felet körs. Med andra ord, om du först kontrollerar Error-klassen på en högre nivå och sedan en underklass till Error-klassen kommer endast den på den högre nivån att överensstämma. I följande exempel illustreras detta:

try 
{ 
    throw new ArgumentError("I am an ArgumentError"); 
} 
catch (error:Error) 
{ 
    trace("<Error> " + error.message); 
} 
catch (error:ArgumentError) 
{ 
    trace("<ArgumentError> " + error.message); 
}

Koden resulterar i följande utdata:

<Error> I am an ArgumentError

Om du vill kunna fånga upp ArgumentError ska du se till att det mest specifika felet listas först och att mer allmänna feltyper listas senare, vilket visas i nästa exempel:

try 
{ 
    throw new ArgumentError("I am an ArgumentError"); 
} 
catch (error:ArgumentError) 
{ 
    trace("<ArgumentError> " + error.message); 
} 
catch (error:Error) 
{ 
    trace("<Error> " + error.message); 
}

Flera metoder och egenskaper i API:t för ActionScript resulterar i körningsfel om ett fel inträffar när de körs. Metoden close() i klassen Sound resulterar exempelvis i ett IOError-fel om metoden inte kan stänga ljudströmmen. Detta visas i nästa exempel:

var mySound:Sound = new Sound(); 
try 
{ 
    mySound.close(); 
} 
catch (error:IOError) 
{ 
    // Error #2029: This URLStream object does not have an open stream. 
}

Efterhand som du blir mer bekant med Referenshandbok för ActionScript 3.0 i Adobe Flash-plattformen kommer du att lära dig vilka metoder som genererar undantag, vilket beskrivs i avsnitten om de olika metoderna.

Flash-miljöerna genererar undantag när de stöter på fel i det program som körs. Du kan dessutom skapa egna undantag genom att använda programsatsen throw. När du vill skapa egna fel rekommenderar Adobe att du använder instanser av klassen Error eller dess underklass. I följande kod visas en throw-sats som returnerar en instans av klassen Error, MyErr, och eventuellt anropar en funktion, myFunction(), för att besvara felet:

var MyError:Error = new Error("Encountered an error with the numUsers value", 99); 
var numUsers:uint = 0; 
try 
{ 
    if (numUsers == 0) 
    { 
        trace("numUsers equals 0"); 
    } 
} 
catch (error:uint) 
{ 
    throw MyError; // Catch unsigned integer errors. 
} 
catch (error:int) 
{ 
    throw MyError; // Catch integer errors. 
} 
catch (error:Number) 
{ 
    throw MyError; // Catch number errors. 
} 
catch (error:*) 
{ 
    throw MyError; // Catch any other error. 
} 
finally  
{ 
    myFunction(); // Perform any necessary cleanup here. 
}

Observera att programsatsen catch är uppställd så att de mest signifikanta datatyperna är listade först. Om catch-satsen för Number-datatypen sätts först kommer varken catch-satsen för uint-datatypen eller catch-satsen för int-datatypen att köras.

En av de största fördelarna med den nya undantags- och felmodellen är att den ger dig möjlighet att meddela användarna när och varför en åtgärd misslyckades. Din del blir att skriva koden för att visa meddelandet och erbjuda alternativa lösningar.

I följande exempel visas en enkel try..catch-sats som visar ett fel i ett textfält:

package 
{ 
    import flash.display.Sprite; 
    import flash.text.TextField; 
     
    public class SimpleError extends Sprite 
    { 
        public var employee:XML =  
            <EmpCode> 
                <costCenter>1234</costCenter> 
                <costCenter>1-234</costCenter> 
            </EmpCode>; 
 
        public function SimpleError() 
        { 
            try 
            { 
                if (employee.costCenter.length() != 1) 
                { 
                    throw new Error("Error, employee must have exactly one cost center assigned."); 
                } 
            }  
            catch (error:Error) 
            { 
                var errorMessage:TextField = new TextField(); 
                errorMessage.autoSize = TextFieldAutoSize.LEFT; 
                errorMessage.textColor = 0xFF0000; 
                errorMessage.text = error.message; 
                addChild(errorMessage); 
            } 
        } 
    } 
}

Tack vare ett stort antal felklasser och inbyggda kompileringsfel erbjuder ActionScript 3.0 mer information än tidigare versioner av ActionScript om varför ett fel har uppstått. Med den här informationen kan du skapa mer stabila program med bättre felhantering.

När du skapar ett program kan det finnas situationer där du måste skicka tillbaka ett fel eftersom du inte kan hantera felet på ett tillfredsställande sätt. I nästa exempel visas ett kapslat try..catch-block, där ett anpassat ApplicationError skickas tillbaka om felet inte kan hanteras i det kapslade catch-blocket:

try 
{ 
    try 
    { 
        trace("<< try >>"); 
        throw new ApplicationError("some error which will be rethrown"); 
    } 
    catch (error:ApplicationError) 
    { 
        trace("<< catch >> " + error); 
        trace("<< throw >>"); 
        throw error; 
    } 
    catch (error:Error) 
    { 
        trace("<< Error >> " + error); 
    } 
} 
catch (error:ApplicationError) 
{ 
    trace("<< catch >> " + error); 
}

Resultatet av det föregående kodutdraget skulle kunna se ut så här:

<< try >> 
<< catch >> ApplicationError: some error which will be rethrown 
<< throw >> 
<< catch >> ApplicationError: some error which will be rethrown

Det kapslade try-blocket ger ett anpassat ApplicationError-fel som fångas upp i det efterföljande catch-blocket. I det kapslade catch-blocket kan felet hanteras och om det lyckas kommer ett ApplicationError-objekt att skickas till det omslutande try..catch-block.