if en JavaScript : exécuter du code seulement quand une condition est vraie

Sans condition, un programme se contente de dérouler la même suite d'instructions pour tout le monde. if est ce qui lui permet de réagir différemment selon les données qu'il reçoit.

C'est la structure la plus simple du langage, et pourtant celle qui produit le plus de comportements inattendus, parce que JavaScript accepte n'importe quelle valeur là où on attendrait un vrai ou un faux.

Définition

if évalue l'expression placée entre parenthèses et n'exécute le bloc qui suit que si le résultat est vrai. Sinon il passe directement à la suite, sans rien signaler.

const stock = 3;

if (stock > 0) {
  console.log("Disponible");   // affiché, car 3 est supérieur à 0
}

Le bloc peut contenir autant d'instructions que nécessaire, y compris d'autres if. Pour couvrir le cas contraire, on ajoute un else, et pour enchaîner plusieurs cas exclusifs, une suite de else if.

Toute valeur devient un booléen

La condition n'a pas besoin d'être une comparaison. JavaScript convertit ce qu'on lui donne, et la liste des valeurs fausses est courte : false, 0, la chaîne vide, null, undefined et NaN. Tout le reste est vrai, y compris un tableau vide.

const remise = 0;

if (remise) {
  console.log("Remise appliquée");   // jamais affiché : 0 est une valeur fausse
}

if (remise !== undefined) {
  console.log("Remise définie");     // celle-ci s'affiche
}

La différence est loin d'être théorique. Tester une quantité, un prix ou un compteur avec un if nu revient à traiter la valeur zéro comme une absence de valeur, et c'est rarement ce qu'on voulait dire. Le vocabulaire Truthy et falsy désigne exactement ce classement.

Comparer sans se faire piéger

Deux opérateurs d'égalité coexistent, et un seul mérite d'être utilisé. Le double signe égal convertit ses opérandes avant de comparer, le triple exige que le type corresponde aussi.

console.log("1" == 1);    // true  : conversion avant comparaison
console.log("1" === 1);   // false : comparaison stricte

La règle est sans nuance : Égalité stricte (===) partout. La forme souple, décrite dans Égalité faible (==), applique une table de conversion que personne ne retient et produit des égalités surprenantes entre valeurs de types différents.

Questions fréquentes

La syntaxe l'autorise quand le bloc ne contient qu'une seule instruction, et c'est une source d'erreurs classique : ajouter une deuxième ligne plus tard donne l'illusion qu'elle appartient à la condition, alors qu'elle s'exécute toujours. Les guides de style imposent les accolades pour cette raison.

Avec les opérateurs logiques : && exige que les deux côtés soient vrais, || se contente d'un seul. Les deux s'arrêtent dès que le résultat est connu, ce qui permet d'écrire un test de présence avant un accès. Pour choisir entre deux valeurs plutôt que deux blocs, l'Opérateur ternaire (?:) tient sur une ligne.

En sortant tôt. Traiter les cas particuliers en haut d'une function avec un return laisse le cas principal aligné à gauche, sans imbrication. Quand l'imbrication vient de la vérification de propriétés successives, le Chaînage optionnel (?.) remplace la cascade de tests par une seule expression.