Tipos de erros

Flash Player 9 e posterior, Adobe AIR 1.0 e posterior

Quando desenvolver e executar aplicativos, você encontrará diferentes tipos de erros e terminologia de erros. A lista a seguir apresenta os principais termos e tipos de erros:

Erros de tempo de compilação são gerados pelo compilador do ActionScript durante a compilação de código. Os erros de compilação ocorrem quando problemas sintáticos no seu código impedem a criação do aplicativo.
Erros de tempo de execução ocorrem quando você executa o aplicativo depois de compilá-lo. Os erros de tempo de execução representam os erros causados quando um arquivo SWF é reproduzido no tempo de execução do Flash (como Adobe Flash Player ou Adobe AIR). Na maioria dos casos, você poderá manipular os erros de tempo de execução assim que eles ocorrerem, relatando-os ao usuário e tomando medidas para manter o aplicativo em execução. Se o erro for fatal, por exemplo, não for possível conectar a um site remoto ou carregar os dados necessários, você poderá usar a manipulação de erros para permitir que o aplicativo seja concluído normalmente.
Os erros síncronos são erros de tempo de execução que ocorrem no momento em que uma função é chamada; por exemplo, quando você tenta usar um método específico e o argumento que transmite para o método é inválido, o tempo de execução do Flash gera uma exceção. A maioria dos erros ocorre de forma síncrona, no momento em que a instrução é executada, e o fluxo de controle transmite imediatamente para a instrução catch mais aplicável.

Por exemplo, o trecho de código a seguir lança um erro de tempo de execução porque o método browse() não é chamado antes de o programa tentar carregar um arquivo:
```
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. 
}
```
Nesse caso, um erro de tempo de execução é lançado de forma síncrona porque o Flash Player determinou que o método browse() não foi chamado antes da tentativa de upload do arquivo.

Para obter informações detalhadas sobre manipulação de erros síncronos, consulte Manipulação de erros síncronos em um aplicativo .
Erros assíncronos são erros de runtime que ocorrem fora do fluxo do programa. Eles geram eventos e os ouvintes de eventos os capturam. Uma operação assíncrona é aquela na qual uma função inicia uma operação, mas não espera ela ser concluída. Você pode criar um ouvinte de eventos de erro que espere o aplicativo ou usuário tentar alguma operação e, se a operação falhar, detecte o erro com um ouvinte de eventos e responda ao evento de erro. Depois, o ouvinte de eventos chama uma função de manipulador de eventos para responder ao evento de erro da melhor maneira. Por exemplo, o manipulador de eventos pode iniciar uma caixa de diálogo que solicite que o usuário resolva o erro.

Considere o exemplo de erro síncrono de carregamento de arquivo apresentado anteriormente. Se você chamar com êxito o método browse() antes de começar a carregar um arquivo, o Flash Player irá despachar vários eventos. Por exemplo, quando um upload é iniciado, o evento open é despachado. Quando a operação de upload de arquivo é concluída com êxito, o evento complete é despachado. Como a manipulação de eventos é assíncrona (isto é, não ocorre em momentos específicos, conhecidos e predeterminados), é necessário usar o método addEventListener() para ouvir esses eventos específicos, como mostra o seguinte código:
```
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..."); 
}
```
Para obter informações detalhadas sobre manipulação de erros assíncronos, consulte Resposta a eventos e status de erros .
Exceções não detectadas são erros lançados sem nenhuma lógica correspondente (como uma instrução catch ) em resposta a elas. Se o seu aplicativo lançar um erro, e nenhuma instrução catch apropriada ou manipulador de eventos puderem ser encontrados no nível atual ou superior para manipular o erro, o erro será considerado uma exceção não detectada.

Quando ocorrer um erro não capturado, o aplicativo gera um erro uncaughtError . Esse evento também é conhecido como “tratamento global de erros”. Este evento é gerado pelo objeto UncaughtErrorEvents do SWF, que está disponível através da propriedade LoaderInfo.uncaughtErrorEvents . Se não houver nenhum ouvinte registrado para o evento uncaughtError , o aplicativo ignorará os erros não capturados e tentará continuar a execução, enquanto o erro não fizer o SWF parar.

Além de gerar o evento uncaughtError , as versões de depurador do tempo de execução do Flash reagem aos erros não capturados por meio do encerramento do script atual. Então, elas exibem o erro não capturado na saída do comando trace ou gravando a mensagem de erro em um arquivo de log. Se o objeto de exceção for uma instância da classe Error ou de uma de suas subclasses, as informações de rastreamento de pilha também serão recebidas na saída. Para obter mais informações sobre como usar a versão de depurador dos tempos de execução do Flash, consulte Trabalho com as versões de depurador dos tempos de execução do Flash .

Nota: Durante o processamento de um evento uncaughtError, se um evento de erro for lançado por um manipulador uncaughtError, o manipulador de evento é chamado várias vezes. Isso resulta em um loop infinito de exceções. Recomenda-se evitar essa situação.