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

try_statements

Las sentencias que serán ejecutadas.

catch_statements_1,catch_statements_2

Sentencias que se ejecutan si una excepción es lanzada en el bloquetry.

exception_var_1,exception_var_2

Identificador que contiene un objeto de excepcion asociado a la cláusulacatch.

condition_1

Una expresión condicional.

finally_statements

Sentencias que se ejecutan después de que se completa la declaracióntry . Estas sentencias se ejecutan independientemente de si una excepcion fue lanzada o capturada.

La sentenciatry consiste en un bloquetry que contiene una o más sentencias. Las llaves{} se deben utilizar siempre, incluso para una bloques de una sola sentencia. Al menos un bloquecatch o un bloquefinally debe estar presente. Esto nos da tres formas posibles para la sentenciatry:

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

Un bloquecatch contiene sentencias que especifican que hacer si una excepción es lanzada en el bloquetry. Si cualquier sentencia dentro del bloquetry (o en una funcion llamada desde dentro del bloquetry) lanza una excepción, el control cambia inmediatamente al bloquecatch . Si no se lanza ninguna excepcion en el bloquetry, el bloquecatch se omite.

La bloquefinally se ejecuta despues del bloquetry y el/los bloque(s)catch hayan finalizado su ejecución. Éste bloque siempre se ejecuta, independientemente de si una excepción fue lanzada o capturada.

Puede anidar una o más sentenciastry. Si una sentenciatry interna no tiene una bloquecatch, se ejecuta el bloquecatch de la sentenciatry que la encierra.

Usted también puede usar la declaracióntry para manejar excepciones de JavaScript. Consulte laGuía de JavaScript para obtener mayor información sobre excepciones de JavaScript.

Cuando solo se utiliza un bloquecatch, el bloquecatch es ejecutado cuando cualquier excepción es lanzada. Por ejemplo, cuando la excepción ocurre en el siguiente código, el control se transfiere a la cláusulacatch.

try {  throw "myException"; // genera una excepción} catch (e) {  // sentencias para manejar cualquier excepción  logMyErrors(e); // pasa el objeto de la excepción al manejador de errores}

El bloquecatch especifíca un identificador (e en el ejemplo anterior) que contiene el valor de la excepción. Este valor está solo disponible en elscope de el bloquecatch.

Tambien se pueden crear "bloquescatch condicionales", combinando bloquestry...catch con estructurasif...else if...else como estas:

try {    myroutine();  // puede lanzar tres tipos de excepciones} catch (e) {    if (e instanceof TypeError) {        // sentencias para manejar excepciones TypeError    } else if (e instanceof RangeError) {        // sentencias para manejar excepciones RangeError    } else if (e instanceof EvalError) {        // sentencias para manejar excepciones EvalError    } else {       // sentencias para manejar cualquier excepción no especificada       logMyErrors(e); // pasa el objeto de la excepción al manejador de errores}

Cuando una excepción es lanzada en el bloquetry,exception_var (por ejemplo, lae encatch (e)) guarda el valor de la excepción. Se puede usar éste identificador para obtener información acerca de la excepción que fue lanzada. Este valor está solo disponible en elscope de el bloquecatch.

function isValidJSON(text) {  try {    JSON.parse(text);    return true;  } catch {    return false;  }}

La cláusulafinally contiene sentencias a ejecutarse después de que las cláusulastry ycatch se ejecuten, pero antes de las sentencias que le siguen al bloquetry..catch..finally. Note que la cláusulafinally se ejecuta sin importar si una excepción es o no lanzada. Si una excepción es lanzada, las instrucciones en la cláusulafinally se ejecutan incluso si ninguna cláusulacatch maneja la excepción.

Usted puede usar la cláusula finally para hacer que su script falle plácidamente cuando una excepción ocurra; por ejemplo, para hacer una limpieza general, usted puede necesitar liberar un recurso que su script haya retenido.

Puede parecer extraño tener una cláusula relacionada a una excepción que se ejecuta sin importar si hay una excepción o no, pero esta concepción en realidad sirve a un propósito. El punto importante no es que la cláusulafinally siempre se ejecuta, si no más bien que el codigo ordinario que le sigue atry..catch no.

Por ejemplo, si otra excepción ocurre dentro de un bloquecatch de una declaracióntry, cualquier codigo restante en el mismo bloque exteriortry que encierra esetry..catch (o en el flujo principal, si no es un bloquetry exterior) , no será ejecutado, dado que el control es inmediatamente transferido al bloquecatch deltry exterior (o el generador de error interno, si no es en un bloquetry).

Por lo tanto, cualquier rutina de limpieza hecha en esa sección encerrada (o la principal) antes de que exista, será saltada. Sin embargo, si la declaracióntry tiene un bloquefinally, entonces el código de ese bloquefinally será ejecutado primero para permitir tal limpieza, y ENTONCES el bloquecatch de la otra declaracióntry (o el generador de error) tomará el control para manejar la segunda excepción.

Ahora, si esa rutina de limpieza debiera ser hecha ya sea que el código deltry..catch tenga éxito o no, entonces si el bloquefinally se ejecutase solo después de una excepción, el mismo código de limpieza tendría que estar presente dentro y fuera del bloquefinally, y por lo tanto no hay razón para no tener el bloquefinally solo, y dejarlo ejecutarse sin importar si hay excepciones o no.

El siguiente ejemplo abre un archivo y despues ejecuta sentencias que usan el archivo (JavaScript del lado del servidor permite acceder a archivos). Si una excepción es lanzada mientras el archivo está abierto, la cláusulafinally cierra el archivo antes de que el script falle. El código enfinally también se ejecuta después de un retorno explícito de los bloquestry ocatch.

openMyFile();try {  // retiene un recurso  writeMyFile(theData);} finally {  closeMyFile(); // siempre cierra el recurso}

Primero, veamos que pasa con esto:

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

Ahora, si nosotros ya capturamos la excepción en una declaración try interna agregando un bloque 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);}// Output:// "inner" "oops"// "finally"

Y ahora vamos a relanzar el error.

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);}// Output:// "inner" "oops"// "finally"// "outer" "oops"

Cualquier excepción dada será capturada solo una vez por el bloque catch más cercano a menos que sea relanzado. Por supuesto cualquier nueva excepción que se origine en el bloque 'interno' (porque el código en el bloque catch puede hacer algo que lanze un error), será capturado por el bloque 'externo'.

Si el bloquefinally retorna un valor, este valor se convierte en el valor de retorno de toda la produccióntry-catch-finally, a pesar de cualquier sentenciareturn en los bloquestry ycatch. Esto incluye excepciones lanzadas dentro del bloque catch.

(function () {  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);  }})();// Output:// "inner" "oops"// "finally"

El "oops" externo no es lanzado debido al retorno en el bloque finally. Lo mismo aplicaría para cualquier valor retornado del bloque catch.

Vea los ejemplos parathrow.

• Error
• throw