Manipulação de erros no ActionScript 3.0

Flash Player 9 e posterior, Adobe AIR 1.0 e posterior

Como muitos aplicativos podem ser executados sem construir a lógica para manipular erros, os desenvolvedores ficam tentados a adiar a criação da manipulação de erros em seus aplicativos. Entretanto, sem isso, um aplicativo pode parar facilmente ou frustrar o usuário caso algo não funcione conforme o esperado. O ActionScript 2.0 possui uma classe Error que permite criar a lógica dentro de funções personalizadas e lançar uma exceção com uma mensagem específica. Como a manipulação de erros é essencial para tornar um aplicativo amigável, o ActionScript 3.0 inclui uma arquitetura expandida para detectar erros.

Nota: Embora a Referência do ActionScript® 3.0 para Adobe® Flash® Platform documente as exceções geradas por muitos métodos, talvez ela não contemple todas as exceções possíveis de cada método. Um método pode gerar uma exceção para erros de sintaxe ou outros problemas que não são observados explicitamente na descrição do método, mesmo quando a descrição lista algumas das exceções que um método gera.

Elementos de manipulação de erros do ActionScript 3.0

O ActionScript 3.0 inclui várias ferramentas para manipulação de erros, incluindo:

  • Classes de erro. O ActionScript 3.0 inclui uma ampla variedade de classes Error para expandir o escopo de situações que podem produzir objetos de erro. Cada classe Error ajuda os aplicativos a manipular e responder a condições de erro específicas, quer estejam relacionadas a erros de sistema (como uma condição MemoryError), erros de código (como uma condição ArgumentError), erros de rede e comunicação (como uma condição URIError) ou a outras situações. Para obter mais informações sobre cada classe, consulte Comparação das classes Error .

  • Menos falhas silenciosas. Nas versões anteriores do Flash Player, os erros eram gerados e relatados somente se você usasse a instrução throw explicitamente. Para o Flash Player 9 e tempos de execução do Flash posteriores, métodos e propriedades originais do ActionScript geram erros de tempo de execução. Esses erros permitem que você trate essas exceções de maneira mais eficaz quando elas ocorrem, depois reaja individualmente a cada exceção.

  • Limpar mensagens de erro exibidas durante a depuração. Ao usar a versão de depurador de um tempo de execução do Flash, situações ou códigos problemáticos geram mensagens de erro robustas, o que ajuda a identificar facilmente os motivos da falha de um bloco de código específico. Essas mensagens tornam mais eficaz a correção dos erros. Para obter mais informações, consulte Trabalho com as versões de depurador dos tempos de execução do Flash .

  • Erros precisos permitem a exibição de claras mensagens de erro aos usuários. Nas versões anteriores do Flash Player, o método FileReference.upload() retornava um valor booliano de false se a chamada upload() não fosse bem-sucedida, indicando um de cinco erros possíveis. Se ocorrer um erro ao chamar o método upload() no ActionScript 3.0, quatro erros específicos ajudam a exibir mensagens de erro mais precisas aos usuários finais.

  • Manipulação de erros refinada. Erros distintos são lançados para várias situações comuns. Por exemplo, no ActionScript 2.0, antes de um objeto FileReference ser preenchido, a propriedade name tem o valor null (portanto, antes de usar ou exibir a propriedade name , é necessário garantir que o valor seja definido e não seja null ). No ActionScript 3.0, se você tentar acessar a propriedade name antes que ela seja preenchida, o Flash Player ou o AIR lançará IllegalOperationError, informando que o valor não foi definido, e você pode usar blocos try..catch..finally para manipular o erro. Para obter mais informações, consulte, Uso das instruções try..catch..finally .

  • Nenhuma desvantagem de desempenho significativa. O uso de blocos try..catch..finally para manipular erros exige poucos (ou nenhum dos) recursos adicionais comparado às versões anteriores do ActionScript.

  • Uma classe ErrorEvent que permite criar ouvintes para eventos de erro assíncronos específicos. Para obter mais informações, consulte Resposta a eventos e status de erros .

Estratégias de manipulação de erros

Contanto que o aplicativo não encontre uma condição problemática, ele poderá ser executado com êxito se você não criar uma lógica de manipulação de erros no seu código. Entretanto, se você não manipular os erros ativamente e seu aplicativo encontrar um problema, seus usuários nunca saberão por que ocorreu uma falha.

Há diferentes maneiras de abordar a manipulação de erros no seu aplicativo. A lista a seguir resume as três principais opções para manipular erros:

  • Usar instruções try..catch..finally . Esses comandos detectarão os erros síncronos que ocorrerem. Você pode aninhar essas instruções em uma hierarquia para detectar exceções em diversos níveis de execução de código. Para obter mais informações, consulte, Uso das instruções try..catch..finally .

  • Criar seus próprios objetos de erro personalizados. Você pode usar a classe Error para criar seus próprios objetos de erro personalizados a fim de controlar operações específicas no seu aplicativo que não estejam incluídas nos tipos de erro embutidos. Depois, você pode usar as instruções try..catch..finally nos seus objetos de erro personalizados. Para obter mais informações, consulte Criação de classes de erros personalizadas .

  • Escreva ouvintes e manipuladores de eventos para responder aos eventos de erro. Usando essa estratégia, você pode criar manipuladores de erro globais que permitem manipular eventos semelhantes sem duplicar uma grande quantidade de código em try.catch..finally . Você tem muito mais chances de detectar erros assíncronos usando essa abordagem. Para obter mais informações, consulte Resposta a eventos e status de erros .