try...catch

Prubalo

try {
  nonExistentFunction();
} catch (error) {
  console.error(error);
  // Expected output: ReferenceError: nonExistentFunction is not defined
  // (Note: the exact output may be browser-dependent)
}

Sintaxis

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 sern ejecutadas.

catch_statements_1, catch_statements_2

Sentencias que se ejecutan si una excepcin es lanzada en el bloque try.

exception_var_1, exception_var_2

Identificador que contiene un objeto de excepcion asociado a la clusula catch.

condition_1

Una expresin condicional.

finally_statements

Sentencias que se ejecutan despus de que se completa la declaracin try . Estas sentencias se ejecutan independientemente de si una excepcion fue lanzada o capturada.

Descripcin

La sentencia try consiste en un bloque try que contiene una o ms sentencias. Las llaves {} se deben utilizar siempre , incluso para una bloques de una sola sentencia. Al menos un bloque catch o un bloque finally debe estar presente. Esto nos da tres formas posibles para la sentencia try:

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

Un bloque catch contiene sentencias que especifican que hacer si una excepcin es lanzada en el bloque try. Si cualquier sentencia dentro del bloque try (o en una funcion llamada desde dentro del bloque try) lanza una excepcin, el control cambia inmediatamente al bloque catch . Si no se lanza ninguna excepcion en el bloque try, el bloque catch se omite.

La bloque finally se ejecuta despues del bloque try y el/los bloque(s) catch hayan finalizado su ejecucin. ste bloque siempre se ejecuta, independientemente de si una excepcin fue lanzada o capturada.

Puede anidar una o ms sentencias try. Si una sentencia try interna no tiene una bloque catch, se ejecuta el bloque catch de la sentencia try que la encierra.

Usted tambin puede usar la declaracin try para manejar excepciones de JavaScript. Consulte la Gua de JavaScript para obtener mayor informacin sobre excepciones de JavaScript.

Bloque catch incondicional

Cuando solo se utiliza un bloque catch, el bloque catch es ejecutado cuando cualquier excepcin es lanzada. Por ejemplo, cuando la excepcin ocurre en el siguiente cdigo, el control se transfiere a la clusula catch.

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

El bloque catch especifca un identificador ( e en el ejemplo anterior) que contiene el valor de la excepcin. Este valor est solo disponible en el scope de el bloque catch.

Bloques catch condicionales

Tambien se pueden crear "bloques catch condicionales", combinando bloques try...catch con estructuras if...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 excepcin no especificada
       logMyErrors(e); // pasa el objeto de la excepcin al manejador de errores
}

El identificador de excepciones

Cuando una excepcin es lanzada en el bloque try, exception_var (por ejemplo, la e en catch (e)) guarda el valor de la excepcin. Se puede usar ste identificador para obtener informacin acerca de la excepcin que fue lanzada. Este valor est solo disponible en el scope de el bloque catch.

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

La clusula finally

La clusula finally contiene sentencias a ejecutarse despus de que las clusulas try y catch se ejecuten, pero antes de las sentencias que le siguen al bloque try..catch..finally. Note que la clusula finally se ejecuta sin importar si una excepcin es o no lanzada. Si una excepcin es lanzada, las instrucciones en la clusula finally se ejecutan incluso si ninguna clusula catch maneja la excepcin.

Usted puede usar la clusula finally para hacer que su script falle plcidamente cuando una excepcin ocurra; por ejemplo, para hacer una limpieza general, usted puede necesitar liberar un recurso que su script haya retenido.

Puede parecer extrao tener una clusula relacionada a una excepcin que se ejecuta sin importar si hay una excepcin o no, pero esta concepcin en realidad sirve a un propsito. El punto importante no es que la clusula finally siempre se ejecuta, si no ms bien que el codigo ordinario que le sigue a try..catch no.

Por ejemplo, si otra excepcin ocurre dentro de un bloque catch de una declaracin try, cualquier codigo restante en el mismo bloque exterior try que encierra ese try..catch (o en el flujo principal, si no es un bloque try exterior) , no ser ejecutado, dado que el control es inmediatamente transferido al bloque catch del try exterior (o el generador de error interno, si no es en un bloque try).

Por lo tanto, cualquier rutina de limpieza hecha en esa seccin encerrada (o la principal) antes de que exista, ser saltada. Sin embargo, si la declaracin try tiene un bloque finally, entonces el cdigo de ese bloque finally ser ejecutado primero para permitir tal limpieza, y ENTONCES el bloque catch de la otra declaracin try (o el generador de error) tomar el control para manejar la segunda excepcin.

Ahora, si esa rutina de limpieza debiera ser hecha ya sea que el cdigo del try..catch tenga xito o no, entonces si el bloque finally se ejecutase solo despus de una excepcin, el mismo cdigo de limpieza tendra que estar presente dentro y fuera del bloque finally, y por lo tanto no hay razn para no tener el bloque finally 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 excepcin es lanzada mientras el archivo est abierto, la clusula finally cierra el archivo antes de que el script falle. El cdigo en finally tambin se ejecuta despus de un retorno explcito de los bloques try o catch.

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

Ejemplos

Bloques try anidados

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 excepcin en una declaracin 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 excepcin dada ser capturada solo una vez por el bloque catch ms cercano a menos que sea relanzado. Por supuesto cualquier nueva excepcin que se origine en el bloque 'interno' (porque el cdigo en el bloque catch puede hacer algo que lanze un error), ser capturado por el bloque 'externo'.

Retornando de un bloque finally

Si el bloque finally retorna un valor, este valor se convierte en el valor de retorno de toda la produccin try-catch-finally, a pesar de cualquier sentencia return en los bloques try y catch. 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 aplicara para cualquier valor retornado del bloque catch.

Vea los ejemplos para throw.

Vea tambin

• Error
• throw