Estrutura try..catch..finally - JavaScript

Durante a execução de um programa, podem ocorrer diversos tipos de erros que interrompem o fluxo normal do programa e podem até fazer com que ele pare de funcionar. O JavaScript possui ferramentas para lidar com essas situações.

callSomeFunc();

console.log("Demais instruções");

Aqui, a função callSomeFunc() é chamada, mas não foi definida em lugar algum. Consequentemente, ao chamar essa função, encontraremos o seguinte erro:

Uncaught ReferenceError: callSomeFunc is not defined

Todas as instruções seguintes, que aparecem depois da linha que causou o erro, não são executadas. O programa termina sua execução.

Essa situação pode parecer forçada, pois sabemos que a função callSomeFunc() não está definida. No entanto, em um programa grande, com várias partes definidas por diferentes desenvolvedores, torna-se mais difícil controlar o código. E tais situações podem ser numerosas. Algumas podemos monitorar e prevenir; outras, não.

Para lidar com tais situações, o JavaScript oferece a estrutura try...catch...finally, que é definida formalmente da seguinte maneira:

try {
// instruções do bloco try
}
catch (error) {
// instruções do bloco catch
}
finally {
// instruções do bloco finally
}

Após o operador try, define-se um bloco de código. Este bloco contém instruções cuja execução pode lançar potenciais erros.

Segue-se o operador catch. Depois desse operador, entre parênteses, especifica-se o nome do objeto que conterá informações sobre o erro. Então vem o bloco catch, que é executado somente se um erro ocorrer no bloco try.

Após o bloco catch, o operador finally introduz seu próprio bloco de instruções, que é executado após os blocos try e catch, independentemente de ter ocorrido um erro ou não.

Vale ressaltar que apenas o bloco try é obrigatório. Um dos outros blocos, catch ou finally, pode ser omitido. No entanto, um deles deve estar presente, seja catch ou finally. Portanto, podemos usar as seguintes variantes desta estrutura:

try...catch
try...finally
try...catch...finally

Por exemplo, vamos lidar com a situação anterior da função inexistente usando esta estrutura:

try {
    callSomeFunc();
    console.log("Fim do bloco try");
}
catch {
    console.log("Ocorreu um erro!");
}
console.log("Demais instruções");

Primeiramente, o bloco try é executado. No entanto, ao executar a primeira instrução - chamar a função callSomeFunc() - um erro ocorre. Isso faz com que todas as instruções subsequentes no bloco try não sejam executadas, e o controle é passado para o bloco catch. Este bloco exibe uma mensagem indicando que ocorreu um erro. Após a execução do bloco catch, as demais instruções do programa são executadas. Assim, o programa não interrompe seu funcionamento ao encontrar um erro e continua a funcionar. Neste caso, a saída no console seria:

Ocorreu um erro!
Demais instruções

Consideremos outro exemplo:

function callSomeFunc() { 
    console.log("Função callSomeFunc executada"); 
}
try {
    callSomeFunc();
    console.log("Fim do bloco try");
}
catch (error) {
    console.log("Ocorreu um erro!");
}

console.log("Demais instruções");

Agora a função callSomeFunc() está definida no programa, então ao chamá-la, nenhum erro ocorre, e o bloco try é concluído até o fim. O bloco catch, na ausência de erros, não será executado. A saída no console seria:

Função callSomeFunc executada
Fim do bloco try
Demais instruções

Captura de Erros no Bloco catch

Dentro do bloco catch, um objeto com informações sobre o erro é passado como parâmetro:

try {
    callSomeFunc();
    console.log("Fim do bloco try");
}
catch (error) {
    console.log("Ocorreu um erro!");
    console.log(error);
}

Neste caso, a saída no console seria:

Ocorreu um erro!
ReferenceError: callSomeFunc is not defined
    at at index.html:35

Bloco Finally

A estrutura try também pode conter um bloco finally. Podemos usar este bloco juntamente com o bloco catch ou em vez dele. O bloco finally é executado independentemente de ter ocorrido um erro ou não. Por exemplo:

try {
    callSomeFunc();
    console.log("Fim do bloco try");
}
catch {
    console.log("Ocorreu um erro");
}
finally {
    console.log("Bloco finally");
}

console.log("Demais instruções");

A saída no console da programa seria:

Ocorreu um erro
Bloco finally
Demais instruções

Se removermos o bloco catch e deixarmos apenas o bloco finally, o erro não será tratado, e o programa terminará com um erro. No entanto, o bloco finally ainda será executado:

try {
    callSomeFunc();
    console.log("Fim do bloco try");
{
finally {
    console.log("Bloco finally");
{

console.log("Demais instruções");

A saída no console seria:

Bloco finally
ReferenceError: callSomeFunc is not defined