Mode strict et gestion des exceptions en Javascript

Javascript peut lever des exceptions de manière explicite, pour cela quelques règles existent et qu’il faut mettre en oeuvre dans son code.

Dans cet article, nous allons voir le mode strict, throw, try…catch et finally.

Mode strict

Le mode strict n’est pas supporté par tous les navigateurs. Ceux qui ne le supportent pas, l’ignoreront.

Si on souhaite que ce mode soit en place dans tous les navigateurs, il faudra alors transpiler son code.

Ce mode élimine les erreurs silencieuse en levant des exceptions avec des erreurs explicites.

Il corrige aussi des erreurs, particulièrement lorsque celles-ci empêche des optimisations au niveau du moteur JavaScript.

On peut invoquer le mode script pour toute la page en le déclarant en haut de celle-ci.

"use strict";
varialeMalDéclarée = 17; // lève une ReferenceError

On peut l’invoquer dans une fonction en le déclarant au début de celle-ci :

function strict() {
    // Syntaxe en mode strict au niveau de la fonction
    'use strict';
    function nested() { return "Ho que oui, je le suis !"; }
        return "Allô ! Je suis une fonction en mode strict ! " + nested();
}
function notStrict() {
    return "Je ne suis pas strict.";
}

throw

L’instruction throw permet de lever une exception définie par l’utilisateur.

L’exécution de la fonction courante sera stopée (les instructions situées après l’instruction throw ne seront pas exécutées) et le contrôle sera passé au premier bloc catch de la pile d’appels.

Si aucun bloc catch ne se trouve dans les fonctions de la pile d’appels, le programme sera terminé.

var person = new Array("joe", "jane")
function getName(id) {
    if (id == null) {
        throw "L'id n'est pas définie";
    }
    return person[id]
}
console.log(getName(1)) // retour: jane
console.log(getName()) // retour: mon-fichier.html:10 Uncaught L'id n'est pas définie

On peut créer ses propres exceptions:

function ExceptionUtilisateur(message) {
    this.message = message;
    this.name = "ExceptionUtilisateur";
}

var person = new Array("joe", "jane")
function ExceptionUtilisateur(message) {
    this.message = message;
    this.name = "ExceptionUtilisateur";
}
function getName(id) {
    if (id == null) {
        throw new ExceptionUtilisateur("L'id n'est pas définie");
    }
    return person[id]
}
console.log(getName(1)) // retour: jane
console.log(getName()) // retour: Uncaught ExceptionUtilisateur {message: "L'id n'est pas définie", name: "ExceptionUtilisateur"}

try…catch

L’instruction try…catch regroupe des instructions à exécuter et définit une réponse si l’une de ces instructions provoque une exception.

var person = new Array("joe", "jane")
function getName(id) {
    if (id == null) {
        throw "L'id n'est pas définie";
    }
    return person[id]
}

try {
    getName(1)
} catch (e){
    console.log(e)
}
try {
     getName()
} catch (e){
    console.log(e) // retourne : L'id n'est pas définie
}

On peut personnaliser la levée d’exception

var person = new Array("joe", "jane")
function ExceptionUtilisateur(message) {
    this.message = message;
    this.name = "ExceptionUtilisateur";
}
function getName(id) {
    if (id == null) {
        throw new ExceptionUtilisateur("L'id  n'est pas définie");
    }
    return person[id]
}

try {
    getName(1)
} catch (e){
    console.log(e)
}
try {
    getName()
} catch (e){
    console.log(e.message, e.name); // 4.html:27 L'id  n'est pas définie ExceptionUtilisateur
}

On peut aussi gérer plusieurs types d’erreurs afin de lever la bonne exception.

try {
    throw new TypeError('Coucou', "unFichier.js", 10);
} catch (e) {
    if (e instanceof TypeError) {
        // les instructions pour gérer TypeError
        console.log('erreur de type TypeError')
    } else if (e instanceof RangeError) {
        // les instructions pour gérer RangeError
        console.log('erreur de type RangeError')
    } else if (e instanceof EvalError) {
        // les instructions pour gérer EvalError
        console.log('erreur de type EvalError')
    } else {
       // les instructions pour gérer les autres exceptions
       console.log(e.message, e.name);
    }
}

finally

finally permet d’exécuter quelque chose après une levée d’exception.

On peut, par exemple, s’en servir pour fermer une connection à une base de données, où fermer un fichier.

try {
    getName(1)
} catch (e){
    console.log(e)
}
try {
    throw new TypeError('Coucou', "unFichier.js", 10);
} catch (e) {
            if (e instanceof TypeError) {
                // les instructions pour gérer TypeError
                console.log('erreur de type TypeError')
            } else if (e instanceof RangeError) {
                // les instructions pour gérer RangeError
                console.log('erreur de type RangeError')
            } else if (e instanceof EvalError) {
                // les instructions pour gérer EvalError
                console.log('erreur de type EvalError')
            } else {
               // les instructions pour gérer les autres exceptions
               console.log(e.message, e.name);
            }
        }
        finally {
            console.log("on est dans finally")
        }