Les accolades sont-elles nécessaires dans les déclarations d'une ligne en JavaScript ?

Question

J'ai entendu dire une fois que laisser les accolades dans les déclarations d'une ligne pouvait être nuisible en JavaScript. Je ne me souviens plus du raisonnement et une recherche sur Google n'a pas été très utile.

Y a-t-il quelque chose qui fasse que ce soit une bonne idée d'entourer toutes les déclarations entre accolades en JavaScript ?

Je pose la question, car tout le monde semble le faire.

Answer 1

No

Mais ils sont recommandés. Si jamais vous élargissez la déclaration, vous en aurez besoin.

C'est parfaitement valable

if (cond) 
    alert("Condition met!")
else
    alert("Condition not met!")

Cependant, il est fortement recommandé de toujours utiliser des accolades, car si vous (ou quelqu'un d'autre) étendez un jour la déclaration, elles seront nécessaires.

Cette même pratique se retrouve dans tous les langages de style syntaxique C avec accolades. Le C, le C++, le Java et même le PHP supportent tous les déclarations d'une ligne sans accolades. Vous devez réaliser que vous ne faites qu'économiser deux personnages et avec les styles d'attelles de certaines personnes, on ne gagne même pas une ligne. Je préfère un style d'entretoise complet (comme les suivants), donc il a tendance à être un peu plus long. Le compromis est très bien trouvé avec le fait que la lisibilité du code est extrêmement claire.

if (cond) 
{
    alert("Condition met!")
}
else
{
    alert("Condition not met!")
}

Answer 2

Il y a un aspect de lisibilité - en ce sens que lorsque vous avez des déclarations composées, cela peut devenir très confus. L'indentation aide mais ne signifie rien pour le compilateur/interprète.

var a;
var b;
var c;

//Indenting is clear
if (a===true)
  alert(a); //Only on IF
alert(b); //Always

//Indenting is bad
if (a===true)
  alert(a); //Only on IF
  alert(b); //Always but expected?

//Nested indenting is clear
if (a===true)
  if (b===true)
    alert(a); //Only on if-if
alert (b); //Always

//Nested indenting is misleading
if (a===true)
  if (b===true)
    alert(a); //Only on if-if
  alert (b); //Always but expected as part of first if?

//Compound line is misleading
//b will always alert, but suggests it's part of if
if (a===true) alert(a);alert(b); 
else alert(c); //Error, else isn't attached

Et puis il y a un aspect extensible :

//Problematic
if (a===true)
  alert(a);
  alert(b); //We're assuming this will happen with the if but it'll happen always
else       //This else is not connected to an if anymore - error
  alert(c);

//Obvious
if (a===true) {
  alert(a); //on if
  alert(b); //on if
} else {
  alert(c); //on !if
} 

L'idée est que si vous avez toujours les crochets, vous savez que vous pouvez insérer d'autres déclarations à l'intérieur de ce bloc.

Answer 3

La question porte sur les déclarations sur une seule ligne. Pourtant, les nombreux exemples fournis montrent des raisons de ne pas omettre les accolades pour les déclarations sur plusieurs lignes. Il est tout à fait possible de ne pas utiliser d'accolades sur une ligne, si c'est le style de codage que vous préférez.

Par exemple, la question demande si cela est acceptable :

 if (condition) statement;

Il ne demande pas si cela est correct :

 if (condition)
   statement;

Je pense qu'il est préférable de ne pas utiliser de parenthèses, car cela rend le code plus lisible, avec moins de syntaxe superflue.

Mon style de codage consiste à ne jamais utiliser de parenthèses, sauf si le code est un bloc. Et de ne jamais utiliser plusieurs instructions sur une même ligne (séparées par des points-virgules). Je trouve cela facile à lire et clair et je n'ai jamais de problèmes de portée sur les instructions "if". Par conséquent, l'utilisation de parenthèses sur une seule déclaration de condition if nécessiterait 3 lignes. Comme ceci :

 if (condition) {
   statement;
 }

Il est préférable d'utiliser une instruction if d'une ligne car elle utilise moins d'espace vertical et le code est plus compact.

Je n'obligerais pas les autres à utiliser cette méthode, mais elle fonctionne pour moi et je ne pourrais pas être plus en désaccord avec les exemples fournis sur la façon dont l'omission des parenthèses entraîne des erreurs de codage/de cadrage.

Answer 4

En plus de la raison mentionnée par @Josh K (qui s'applique également à Java, C, etc.), un problème particulier en JavaScript est le suivant insertion automatique du point-virgule . D'après l'exemple de Wikipedia :

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;

Donc, cela peut aussi donner des résultats inattendus, si on l'utilise comme ça :

if (x)
   return
   a + b;

Ce n'est pas vraiment mieux d'écrire

if (x) {
   return
   a + b;
}

mais peut-être qu'ici l'erreur est un peu plus facile à détecter ( ?)

Answer 5

C'est une question de style, mais les accolades bouclées sont bonnes pour prévenir d'éventuelles d'autres qui pendent .