Entrar al aula
×

Funciones para controlar los errores en Javascript

En JavaScript, desde la versión 1.4, hay una sentencia pensada para el tratamiento de errores que es tryEs el bloque de código que tendremos que definir de manera obligatoria cuando estemos trabajando con control de errores o excepciones y en el que se definirán las sentencias de código que pueden provocar un error en su ejecución y que por lo tanto queremos controlar. /catchEs un bloque de código utilizado en el control de excepciones en algunos lenguajes de programación y en el que se capturan los errores que puedan producirse en el bloque try, pudiendo establecer en caso de que sea necesario el tipo de error que queremos controlar. Pueden utilizarse varios bloques catch en los que se controlen diferentes excepciones. Suele ir acompañado por un bloque finally de ejecución no opcional. /finallyEs un bloque de código utilizado en el control de excepciones junto con los bloques try y catch, ejecutado siempre en último lugar, independientemente de que se hayan producido errores o no, y que se utiliza para establecer las instrucciones que queremos que se ejecuten pase lo que pase en los bloques try/catch. .

Utilidad de la sentencia

Una sentencia try agrupa las instrucciones en las que queramos controlar si se producen errores y después nos permitirá interceptar dichos errores mediante la sentencia catch.

Utilización del try catch 

El control de los posibles errores de un script se divide en dos bloques:

Sintaxis

 try {
    // Aquí va el código controlado
} catch(excepcion) {
    // Aquí se controla el error
}
Bloque try/catch/finally

En el bloque try, que es obligatorio, se incluye el código que va a ser ejecutado mientras que en el bloque catch se incluyen las instrucciones que se ejecutarán en caso de que suceda algún error. Además del bloque try también deberá existir al menos un bloque catch o un bloque finally.

Función del bloque catch

El bloque catch capturará los errores que se produzcan en el bloque try, ya sea que allí haya instrucciones concretas o llamadas a funciones.

El bloque finally se ejecutará siempre, independientemente de que en el bloque try se produzcan errores o no. Se podrá usar para realizar operaciones que deban realizarse siempre.

Retorno del valor

Si una de las instrucciones del bloque try es un return, el valor de retorno se pondrá en una cola y antes de devolverlo, se ejecutará el bloque finally en caso de existir, y tras su ejecución, se devolverá el valor de la instrucción return.
Gestión de los errores

A continuación vemos un ejemplo para probar la gestión de errores, en el que utilizaremos el ejemplo de código anteriormente mostrado para provocar un error en ejecución:

Gestión de los errores

 <html>
    <head>
        <title>Control de errores JavaScript</title>
        <meta charset="UTF">
    </head>
    <body>
        <script>
            function Coche(matricula) {
                this.matricula = matricula;
                this.getMatricula = getMatricula;
            }

            function getMatricula() {
                alert(this.matricula);
            }

            var coche;

            try {
                coche.getMatricula();
            } catch(err) {
                alert('El objeto coche no existe');
            }
        </script>
    </body>
</html>

Dentro del bloque try hemos introducido la función coche.getMatricula() en la que ya sabemos que en esta parte es en la que se va a lanzar una excepción o error. Dentro del bloque catch lanzamos una alerta en el caso de que surja el error. El parámetro que utiliza la instrucción catch es el objeto que se creará automáticamente y que incluirá la información del error producido (número de error y mensaje de error).

Instrucción throwEs una instrucción utilizada para lanzar o provocar una excepción, que permite enviar al navegador un evento similar al ocasionado cuando se produce algo inesperado. Podemos así definir el mensaje que queremos obtener cuando se produzca un error determinado, ya sea con números, objetos, valores booleanos o de otro tipo.

Por otra parte, podemos crear nuestras propias situaciones que consideremos un error en la lógica de la programación. Por ejemplo, en un programa de gestión que un usuario no registrado intente realizar una compra podría producir una situación que debería ser gestionada de forma especial, por ejemplo, mediante un bloque catch. Para crear este tipo de problemáticas tenemos a nuestra disposición en JavaScript otra instrucción.

Instrucción throw

La instrucción throw “lanzará” o provocará un error generado por nosotros con un valor, que podrá ser cualquiera válido en el lenguaje JavaScript.

La sintaxis será:

Sintaxis

 throw "valor";

Gestión del error

Incluiremos esta instrucción en un bloque try y como consecuencia de su ejecución, el flujo del programa irá a un bloque catch, al primero que pueda gestionar el error generado.
Probar la estructura recursivamente

Vamos a probar la estructura try/catch/finally de forma recursiva para mostrar mensajes en todos los bloques y lanzar también nuestro propio error, con un código que definimos como el 301 (podría ser cualquier otro) y un texto de error. Podríamos usarlo para el propósito que queramos. Utilizaremos la instrucción document.write para escribir mensajes en el navegador.

Estructura try/catch/finally

 <!DOCTYPE html>
<html>
    <head>
        <title>Control de errores JavaScript</title>
        <meta charset="UTF">
    </head>
    <body>
        <script>
            try {
                document.write("Primer bloque con control de errores try.<br>");
                try {
                    document.write("Segundo bloque con control de errores try.<br>");
                    throw new Error(301, "Generamos un error con código 301.");
                }
                catch (e) {
                    document.write ("Código que se ejecutará tras el error " + e.message + " generado por nosotros con throw.<br/>");
                    document.write (e + "<br>");
                    throw e; // Generamos otro error
                }
                finally {
                    document.write ("Este bloque se ejecutará siempre y pertenece al bloque finally.<br>");
                }
            }
            catch (e) {
                document.write ("Otro código que se ejecutará en caso de error " + e.message + ".<br>");
            }
            finally {
                document.write ("Otro código que se ejecutará siempre de bloque finally final.");
            }
        </script>
    </body>
</html>

Veamos la salida que ofrecerá el navegador:

Propiedades y errores

Las propiedades relacionadas con el objeto que manejará los errores en los bloques catch son:

message
El mensaje de error.
name
El nombre del error.
stackEs una estructura en forma de pila que permite almacenar y obtener los datos contenidos en ella, como pueden ser los errores ocurridos en la ejecución de un programa. El tamaño de esta estructura se suele definir al comienzo del programa y si el contenido supera los límites permitidos puede producirse un desbordamiento de la pila (stack overflow).
Pila de errores, aunque no es utilizado por todos los navegadores, sí lo usa Chrome y Firefox.

Las fuentes de los errores más típicos suelen ser externos, como una entrada de datos de usuario errónea, un fichero perdido o mal referenciado, o internos, como por un fallo de nuestro programa.

Excepciones no esperadas

En este último caso, podemos recibir en el navegador excepciones no esperadas que tendremos que depurar. Habitualmente no tendremos un debugger o depurador que nos lo proporcione nuestro editor y tendremos que hacerlo a mano.
Información útil

Hay dos tipos de información que serán muy útiles:

Datos
Los datos que tienen nuestras variables.
Lugar de la excepción
La línea en la que se produjo la excepción y qué llamadas a qué funciones se habían producido.

Con respecto a los datos de nuestras variables se pueden indicar tanto en el mensaje como en las propiedades de un objeto tipo excepción.

Pila de llamada de funciones

Con respecto a lo segundo, hay muchos motores de JavaScript que ofrecen información de la pila de llamadas de funciones (en inglés stack traces), donde los objetos de tipo excepción fueron creados.

El siguiente ejemplo lo ilustrará. Supongamos un fichero con nombre ejemplo.js con este código:

Definición de funciones

 function capturalo() {
    try {
        lanzalo();
    } catch(e) {
        console.log(e.stack); // Imprime la pila de llamadas
    }
}

function lanzalo() {
    throw new Error('');
}

Al ejecutarlo veremos la respuesta:

Respuesta de la ejecución

 capturalo()
Error
    at lanzalo (~/ejemplo.js:9:11)
    at capturalo (~/ejemplo.js:3:9)
    at repl:1:5
Actividad de autoevaluación: Try/Catch