try...catch

Sintaxe

try {
   try_statements
}
[catch (exception_var_1 if condition_1) {
   catch_statements_1
}]
...
[catch (exception_var_2) {
   catch_statements_2
}]
[finally {
   finally_statements
}]

try_statements

Declaraes (statements) a serem executadas.

catch_statements_1, catch_statements_2

Declaraes que so executadas se uma exceo lanada no bloco try.

exception_var_1, exception_var_2

Um indentificador que leva um objeto exceo para uma clusula catch associada.

condition_1

Uma expresso condicional.

finally_statements

Declaraes que so executadas depois que a declarao try completada. Essas declaraes so executadas independetemente se uma exceo foi ou no lanada ou capturada.

Descrio

A declarao try consiste em um bloco try, que contm uma ou mais declaraes, e ao menos uma clusula catch ou uma clusula finally, ou ambas. Ou seja, h 3 formas de declaraes try :

1. try...catch
2. try...finally
3. try...catch...finally

Uma clusula catch contm declaraes que especificam o que fazer caso uma exceo seja lanada no bloco try. Ou seja, se voc quer que o bloco try tenha xito, e caso no tenha, voc quer que o controle passe para o bloco catch. Caso qualquer declarao dentro do bloco try (ou em uma funo chamada no interior do bloco try) lanar uma exceo o controle imediatamente muda para a clusula catch. Se nenhuma exceo for lanada no bloco try a clusula catch ignorada.

A clusula finally executada aps a excecuo do bloco try e da(s) clusula(s) catch porm antes das declaraes seguintes ao try. Ela sempre executada, independente se uma exceo for lanada ou capturada.

Voc pode aninhar uma ou mais declaraes try. Caso uma declarao try interior no tenha uma clusula catch, a clusula catch pertencente a declarao try que a envolve introduzida.

Voc pode usar a declarao try para manipular excees em JavaScript. Veja o Guia Javascript para informaes sobre excees em JavaScript.

Clusula catch incondicional

Quando uma nica, incondicional clusula catch utilizada, o bloco catch inserido quando qualquer exceo for lanada. Por exemplo, quando a exceo ocorre no cdigo a seguir, o controle transferido para a clusula catch.

try {
  throw "myException"; // gera uma exceo
} catch (e) {
  // declaraes para manipular quaisquer excees
  logMyErrors(e); // passa o objeto de exceo para o manipulador de erro
}

Clusulas catch condicionais

Voc pode utilizar uma ou mais clusulas catch condicionals para manipular excees especficas. Nesse caso a clusula catch apropriada ser inserida quando a exceo espeficica for lanada. No exemplo a seguir, o cdigo no bloco try pode potencialmente jogar trs excees: TypeError, RangeError, e EvalError. Quando a exceo ocorre, o controle transfere para a clusula catch apropriada. Caso a exceo no seja uma das especificadas e uma clusula catch incondicional for encontrada, o controle transferido para essa clusula catch.

Se utilizar uma clusula catch incondicional com uma ou mais clusulas catch condicionais, o catch incondicional deve ser especificado por ltimo. Caso contrrio, o catch incondicional interceptar todos os tipos de exceo antes que eles alcancem os condicionais.

Nota: Essa funcionalidade no parte da especificao ECMAScript.

try {
    myroutine(); // pode lanar trs tipos de excees
} catch (e if e instanceof TypeError) {
    // declaraes para manipular excees TypeError
} catch (e if e instanceof RangeError) {
    // declaraes para manipular excees RangeError
} catch (e if e instanceof EvalError) {
    // declaraes para manipular excees EvalError
} catch (e) {
    // declaraes para manipular quaisquer excees no especificadas
    logMyErrors(e); // passa o objeto de exceo para o manipulador de erro
}

E aqui temos como implementar as mesmas "clusulas catch condicionais" utilizando apenas JavaScript puro conforme a especificao ECMAScript (obviamente mais verboso, porm, funciona em qualquer lugar):

try {
    myroutine(); // pode lanar trs tipos de excees
} catch (e) {
    if (e instanceof TypeError) {
        // declaraes para manipular excees TypeError
    } else if (e instanceof RangeError) {
        // declaraes para manipular excees RangeError
    } else if (e instanceof EvalError) {
        // declaraes para manipular excees EvalError
    } else {
       // declaraes para manipular quaisquer excees no especificadas
       logMyErrors(e); // passa o objeto de exceo para o manipulador de erro
    }
}

O identificador de exceo

Quando uma exceo lanada no bloco try, exception_var (ex. o e dentro de catch (e)) armazena o valor especificado pela declarao throw. Voc pode usar esse identificador para conseguir informao sobre a exceo que foi lananda.

Esse identificador local para a clusula catch. Ou seja, criado quando a clusula catch introduzida e aps terminar sua excecuo o identificador no se torna mais disponvel.

A clusula finally

A clusula finally executada aps a excecuo do bloco try e da(s) clusula(s) catch porm antes das declaraes seguintes a declarao try. Ela sempre executada, independente se uma exceo for lanada ou capturada.

A clusula finally contm declaraes para executarem aps a execuo do bloco try e da(s) clusula(s) catch porm antes das declaraes seguintes a declarao try. A clusula finally excutada independente se uma exceo for lanada ou no. Caso uma exceo seja lanada, as declaraes no interior da clusula finally so executadas mesmo que nenhum catch manipule a exceo.

Voc pode utilizar a clusula finally para fazer seu script falhar graciosamente quando uma exceo ocorrer; por exemplo, voc pode precisar liberar um recurso que seu script possui vinculado. O exemplo seguinte abre um aquivo e ento executa declaraes que utilizam o arquivo (server-side JavaScript permite que voc acesse arquivos). Se uma exceo for lanada enquanto o arquivo estiver aberto, a clusula finally fecha o arquivo antes que o script falhe.

openMyFile();
try {
  // vincula o recurso
  writeMyFile(theData);
} finally {
  closeMyFile(); // sempre fecha o recurso
}

Exemplos

Blocos try aninhados

Primeiro vamos ver o que acontece com isso:

try {
  try {
    throw new Error("oops");
  }
  finally {
    console.log("finally");
  }
}
catch (ex) {
  console.error("outer", ex.message);
}

// Resultado
// "finally"
// "outer" "oops"

Agora, caso ns j capturamos a exceo no bloco try interno adicionando um bloco catch

try {
  try {
    throw new Error("oops");
  }
  catch (ex) {
    console.error("inner", ex.message);
  }
  finally {
    console.log("finally");
  }
}
catch (ex) {
  console.error("outer", ex.message);
}

// Resultado:
// "inner" "oops"
// "finally"

E agora, vamos relanar o erro.

try {
  try {
    throw new Error("oops");
  }
  catch (ex) {
    console.error("inner", ex.message);
    throw ex;
  }
  finally {
    console.log("finally");
  }
}
catch (ex) {
  console.error("outer", ex.message);
}

// Resultado:
// "inner" "oops"
// "finally"
// "outer" "oops"

Qualquer exceo lanada ser capturada apenas uma vez pelo bloco catch envolvente mais prximo, a no ser que seja relanada. Obviamente qualquer nova exceo elevada no bloco "interno" (pois cdigo em um bloco catch pode fazer algo que lance), ser capturado pelo bloco "externo".

Retornando de um bloco finally

Caso o bloco finally retorne um valor, esse valor torna-se o valor de retorno do produto de try-catch-finally inteiro, independente de qualquer declarao return nos blocos try e catch. Isso inclui excees lanadas dentro do bloco catch:

try {
  try {
    throw new Error("oops");
  }
  catch (ex) {
    console.error("inner", ex.message);
    throw ex;
  }
  finally {
    console.log("finally");
    return;
  }
}
catch (ex) {
  console.error("outer", ex.message);
}

// Resultado:
// "inner" "oops"
// "finally"

O "oops" externo no lanado devido ao retorno do bloco finally. O mesmo se aplicaria a qualquer valor retornado do bloco catch.

Vejam tambm

• throw
• Error