On ne le dira jamais assez, le javascript est l »un des langages les plus imcompris, souvent désigné comme le vilain petit canard dans le monde du développement. Cette incompréhension vient surtout d »un manque de connaissance des mécanismes de ce langage. A l »heure actuelle la révolution du javascript est en marche et risque bien de tout écraser sur son passage. Afin que vous ne passiez pas à coté de ce retour en force, je vais vous éclairer sur plusieurs mécanismes qu »il est nécessaire de connaitre afin de coder proprement en js et surtout afin d »être fin prêt pour s »attaquer à des technologies comme NodeJs. Commençons par les wrapper object.

En JavaScript presque tout est objet. Cependant il existe des types primitifs tel que string, int, boolean,… qui ne sont pas des objets. Et pourtant il est possible d’accéder à des propriétés à partir de ces types comme le montre l’exemple suivant :

var myVar = "maChaine";
alert(myVar.length);

En voyant le code ci-dessus on peut se dire que finalement la variable myVar est un objet String puisqu’il a une propriété nommé length. Pourtant le code suivant prouve que myVar est bien une variable de type string et non un objet :

var myVar = "maChaine";
myVar.myProperty = 6;
var myVar2 = new String("maChaine");
myVar2.myProperty = 6;
alert(myVar.myProperty);
alert(myVar2.myProperty);

Hein ???? Mais pourquoi donc le premier alert affiche-t-il undifined ??? Et bien lorsqu’on crée la variable myVar et qu’on lui affecte la chaîne « maChaine », myVar devient une valeur de type string. Lorsqu’on fait appel à la propriété length, la variable myVar est utilisée pour initialiser un objet String de la façon suivante : new String(myVar). Cet objet est appelé un wrapper object (objet encapsuleur) car il encapsule temporairement notre variable. Il hérite de toutes les propriétés de l’2014-02-20 17:02:37’objet String et est utilisé pour résoudre la référence à la propriété length. Une fois que l’appel à la propriété est fini, l’objet est détruit. 

Dans le second exemple ci-dessus on crée donc une variable myVar de type string. Avec l’instruction myVar.myProperty, un objet temporaire String est créé et la propriété « myProperty » est setter puis l’objet est détruit. Du coup lors du premier alerte la propriété « myProperty » n’existe plus ! On peut illustrer le fonctionnement des wrapper object de cette façon :

var myVar = "maChaine";
var temp = new String(myVar);
temp.myProperty = 6;
//Puis l'objet temp est détruit

Les wrapper object sont également utilisés dans le cas des types number et boolean. Certain opérateurs impliquent l’utilisation des wrapper object. Ils permettent la conversion implicite d’une valeur. Cette notion permet par exemple de comprendre la différence entre l’operateur « == » et « === ». Le premier compare 2 valeurs et le second compare les 2 valeurs et leurs types. Le premier opérateur utilise les wrapper object sur les valeurs de type primitif lors de la comparaison, pas le second. Voici un exemple :

var myVar = "maChaine"; // myVar est un type primitf string
var myVar2 = new String("maChaine"); // myVar2 est un objet String
alert(myVar == myVar2); //Retourne true car la variable myVar est encapsuler à l’aide d’un wrapper object : temp = new String(myVar);
alert(myVar === myVar2); // Retourne false car la variable myVar n’est pas encapsuler. 

Pour plusieurs raisons il ne faut surtout pas utiliser les object wrapper directement. En effet, lors de l »utilisation d »un type primitif l »object wrapper qui encapsule la variable est directement détruit après utilisation alors qu »un object wrapper instancier explicitement ne sera détruit que si l »on supprime la référence à l’objet. De plus les wrapper object ne correspondent généralement pas au comportement attendu d’un type primitif équivalent. L’exemple le plus flagrant est le suivant :

var myBoolean = new Boolean(false);
if (myBoolean) {
    alert("true");
}

L’alert affiche true ???? Et oui, car l’expression est considérée comme fausse seulement si elle retourne une valeur dite « falsey » qui sont null, undifined, 0, «  » ou false. Ici myBoolean est évalué en tant qu »objet et retourne donc true.

Avec ces différents exemples vous comprenez maintenant la différence entre un wrapper object et le type primitif associé. Ce qu »il faut principalement retenir est que les objet String, Number et Boolean existent et sont très utiles, mais ne doivent être en aucun cas être utilisés directement. D »ailleurs si vous utilisez des outils pour contrôler la qualité de vos scripts (tel que JSLint, JSHint, … ), essayez d »instancier un wrapper object directement et voyez ce qu »il en pense :).

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.