Tout d'abord, les faits :
if (booleanValue)
satisfera les if pour toute valeur véridique de booleanValue y compris true tout nombre non nul, toute valeur de chaîne non vide, toute référence d'objet ou de tableau, etc...
D'un autre côté :
if (booleanValue === true)
Cela ne fera que satisfaire la if condition si booleanValue est exactement égal à true . Aucune autre valeur véridique ne pourra le satisfaire.
D'un autre côté, si vous faites ça :
if (someVar == true)
Ensuite, ce que Javascript fera est de taper coerce true pour correspondre au type de someVar et ensuite comparer les deux variables. Il existe de nombreuses situations où ce n'est probablement pas ce que l'on souhaite. Pour cette raison, dans la plupart des cas, vous voulez éviter == parce qu'il y a un ensemble assez long de règles sur la façon dont Javascript va forcer deux choses à être du même type et à moins que vous compreniez toutes ces règles et que vous puissiez anticiper tout ce que l'interpréteur JS pourrait faire lorsqu'il reçoit deux types différents (ce que la plupart des développeurs JS ne peuvent pas faire), vous voulez probablement éviter == entièrement.
Pour illustrer à quel point cela peut être déroutant :
var x;
x = 0;
console.log(x == true); // false, as expected
console.log(x == false); // true as expected
x = 1;
console.log(x == true); // true, as expected
console.log(x == false); // false as expected
x = 2;
console.log(x == true); // false, ??
console.log(x == false); // false
Pour la valeur 2 on pourrait penser que 2 est une valeur véridique, elle se compare donc favorablement à true mais ce n'est pas ainsi que fonctionne la coercition de type. Il convertit la valeur de droite pour qu'elle corresponde au type de la valeur de gauche, c'est à dire qu'il convertit true au nombre 1 donc il s'agit de comparer 2 == 1 ce qui n'est certainement pas ce que vous vouliez.
Donc, attention à l'acheteur. Il est probablement préférable d'éviter == dans presque tous les cas, à moins de connaître explicitement les types à comparer et de savoir comment fonctionnent tous les algorithmes de coercition de types possibles.
Donc, cela dépend vraiment des valeurs attendues pour booleanValue et comment vous voulez que le code fonctionne. Si vous savez à l'avance qu'il n'y aura jamais qu'un seul code de type true o false puis en la comparant explicitement avec
if (booleanValue === true)
est juste du code supplémentaire et inutile et
if (booleanValue)
est plus compact et sans doute plus propre/meilleur.
Si, d'un autre côté, vous ne savez pas ce que booleanValue et vous voulez tester s'il est vraiment réglé sur true sans qu'aucune autre conversion automatique de type ne soit autorisée, alors
if (booleanValue === true)
n'est pas seulement une bonne idée, mais une nécessité.
Par exemple, si vous regardez l'implémentation de la fonction .on() dans jQuery, il a une valeur de retour optionnelle. Si le callback renvoie false alors jQuery arrêtera automatiquement la propagation de l'événement. Dans ce cas précis, puisque jQuery veut arrêter la propagation UNIQUEMENT si false a été retourné, ils vérifient la valeur de retour explicitement pour === false parce qu'ils ne veulent pas undefined o 0 o "" ou tout autre élément qui sera automatiquement converti en faux pour satisfaire également la comparaison.
Par exemple, voici le code de rappel du traitement des événements de jQuery :
ret = ( specialHandle || handleObj.handler ).apply( matched.elem, args );
if ( ret !== undefined ) {
event.result = ret;
if ( ret === false ) {
event.preventDefault();
event.stopPropagation();
}
}
Vous pouvez voir que jQuery recherche explicitement ret === false .
Mais, il y a aussi beaucoup d'autres endroits dans le code de jQuery où une vérification plus simple est appropriée étant donné le désir du code. Par exemple :
// The DOM ready check for Internet Explorer
function doScrollCheck() {
if ( jQuery.isReady ) {
return;
}
...
