Sentencia try...catch
La sentencia try...catch marca un bloque de las instrucciones a probar y especifica una o más respuestas al producirse una excepción. La sentencia try...catch es la que se ocupa de la excepción.
La sentencia try...catch consiste de un bloque try, el cual contiene una o más sentencias y cero o más bloques catch, conteniendo sentencias que especifican que hacer si una excepción es lanzada en el bloque a probar {{ mediawiki.external('try block') }}. Esto es, si desea que el bloque try suceda y si este no sucede, desea controlar el paso al bloque catch. Si cualquier sentencia dentro de un bloque try (o en una función llamada dentro de el bloque try) lanza una excepción, el control immediatamente cambia al bloque catch. Si no sucede el lanzamiento de ninguna excepción en el bloque try, el bloque catch es saltado. El bloque finally se ejecuta después de los bloques try y los bloques catch se ejecutan pero antes de las sentecias seguidas de la sentencia try...catch.
El ejemplo siguiente utiliza una sentencia try...catch. El ejemplo invoca una función que recupera un nombre de mes desde un arreglo basado en los valores pasados a la función. Sí el valor no corresponde a un número de mes (1-12), una excepción es lanzada con el valor Número_mes_Inválido y las sentencias en el bloque catch configuran la variable Nombremes a desconocido {{ mediawiki.external('unknown') }}.
function encuentraNombredelMes (mes) {
mes=mes-1; // Ajusta el número del mes por el índice de lista (1=Enero, 12=Diciembre)
var meses=new Array("Enero","Febrero","Marzo","Abril","Mayo","Junio","Julio","Agosto","Septiembre","Octubre","Noviembre","Diciembre");
if (meses[mes] != null) {
return meses[mes]
} else {
throw "Número_mes_Inválido"
}
}
try {
// instrucciones a probar
Nombremes =encuentraNombredelMes (miMes) // función que podría lanzar una excepción
}
catch (e) {
Nombremes ="desconocido"
logMisErrores(e) // pasa el objeto excepción al manejador de errores
}
El bloque catch
Puede utilizar un sólo bloque catch para manipular todas las excepciones que pueden ser generadas en el bloque try, o puede utilizar bloques separados catch cada uno de los cuales manipula un tipo particular de excepción.
Un sólo bloque de captura
Utilize un sólo bloque catch de sentencias try...catch(bloque de recuperación) para ejecutar un código manejador de errores para cualquier excepción lanzada en el bloque try.
Un sólo bloque catch tiene la siguiente sintaxis:
catch (catchID) {
sentencias
}
El bloque catch especifica un identificador (catchID en la sintaxis anterior) que mantiene el valor especificado por la sentencia throw; puede utilizar este identificador para obtener información acerca de la excepción que fue lanzada. JavaScript crea este identificador cuando el bloque catch es ingresado; el identificador dura solamente lo que dure el bloque catch; después de que el bloque catch finalice la ejecución, el identificador no está más disponible.
Por ejemplo, el siguiente código lanza una excepción. Cuando la excepción ocurre, el control se transfiere al bloque catch.
try {
throw "miExcepcion" // genera una excepción
}
catch (e) {
// sentencias para manipular cualquier excepción
logMisErrores(e) // pasa el objeto excepción al manipulador de errores
}
Múltiples bloques de captura
Una sola sentencia try puede contener múltiples bloques catch condicionales, cada uno de los cuales manipula un tipo específico de excepción. En este caso, el bloque condicional catch apropiado es ingresado solamente cuando la excepción especificada para ese bloque es lanzada. Puede también incluir un bloque opcional catch-all catch en la sentencia para todas la excepciones no especificadas como un bloque final de captura {{ mediawiki.external('final catch block') }}.
Por ejemplo, la siguiente función invoca otras tres funciones (declaradas en cualquier lugar), las cuales validan sus argumentos. Si una función de validación determina que el componente que está siendo chequeado es inválido, retorna 0, causando que el lanzador lanze una excepción particular.
function obtenerInformaciónCliente(nombre, id, email)
{
var n, i, e;
if (!valida_nombre(nombre))
throw "ExcepciónNombreInválido"
else
n = nombre;
if (!valida_id(id))
throw "ExcepciónIdInválido"
else
i = id;
if (!valida_email(email))
throw "ExcepciónEmailInválido"
else
e = email;
cliente = (n + " " + i + " " + e);
return (cliente);
}
Los bloques condicionales catch rutean el control al manejador de excepciones apropiado.
try {
// función que debería lanzar tres excepciones
obtenerInformaciónCliente("Lee", 1234, "[email protected]")
}
catch (e if e == "ExcepciónNombreInválido") {
// invocar al manejador para nombres inválidos
manejador_nombre_erroneo(e)
}
catch (e if e == "ExcepciónIdInválido") {
// invocar al manejador para ids inválidos
manejador_id_erroneo(e)
}
catch (e if e == "ExcepciónEmailInválido") {
// invocar al manejador para direcciones e-mail inválidas
manejador_email_erroneo(e)
}
catch (e){
// No se que hacer pero lo registro en un log
logError(e)
}
El bloque finally
El bloque finally contiene sentencias para ejecutar después de que se ejecuten los bloques {{ mediawiki.external('try y catch') }} pero antes de las sentencias seguidas de la sentencia try...catch. El bloque finally se ejecuta sin importar que una excepción sea lanzada o no. Si una excepción es lanzada, las sentencias en el bloque finally se ejecutan aún si los manejadores de bloques no capturan la excepción.
Puede utilizar el bloque finally para hacer que su script falle graciosamente cuando ocurra una excepción, por ejemplo, puede necesitar liberar un recurso que su script lo tiene reservado. El siguiente ejemplo abre un archivo y luego ejecuta sentencias que utilizan el archvo (del lado del servidor JavaScript le permite acceder a archivos). Si una excepción es lanzada mientras el archivo es abierto, el bloque finally cierra el archivo antes de que el script falle.
abrirMiArchivo();
try {
escribirMiArchivo(losDatos); //Esto puede lanzar un error
}catch(e){
handleError(e); // Si se tiene un error lo manipulamos
}finally {
cierreMiArchivo(); // siempre cierra el recurso
}
Sentencias try...catch anidadas
Puede anidar una o más sentencias try...catch. Si una sentencia interna try...catch no posee un bloque de captura, el bloque de captura de la sentencia de cierre try...catch es chequeado por una coincidencia.
{{ AnteriorSiguiente("Guía_JavaScript_1.5:Sentencias_de_manejo_de_excepciones:throw", "Guía_JavaScript_1.5:Definiendo_Funciones") }}