La meilleure solution est évidemment de ne pas imbriquer vos commentaires. Les commentaires imbriqués sont généralement le signe que vous utilisez mal les commentaires. L'exemple le plus courant est le code mis en commentaire qui contient les commentaires lui-même, et le correctif consiste à supprimer le code au lieu de le commenter.
Cela dit, de nombreux langages de programmation ont plus d'un type de syntaxe de commentaire, et vous pouvez utiliser ce fait pour imbriquer au moins un niveau en profondeur. Par exemple, en Java:
/* This is commented out!
Foo.bar.baz();
// And now for something completely different...
Quux.runWith(theMoney);
*/
De plus, dans de nombreuses langues, au moins un type de commentaire peut être imbriqué; dans les langages de type C, les commentaires de ligne dans les commentaires de ligne sont ignorés:
// some_commented_out(code);
// // This is a comment inside the comment!
// // Still inside the nested comment.
// some_more_code_in(outer_comment);
La plupart des IDE prennent en charge le commentaire de blocs entiers de code avec des commentaires de ligne en une seule action, et ils gèrent correctement ce type de style de commentaire. Le même exemple en Python:
# some_commented_out(code)
# # This is a comment inside the comment!
# # Still inside the nested comment.
# some_more_code_in(outer_comment)
Souvent, les normes de codage pour un projet particulier ont des règles sur le style de commentaire à utiliser quand; une convention courante consiste à utiliser des commentaires de bloc ( /* */
) pour la documentation des méthodes et des classes, et des commentaires en ligne ( //
) pour les remarques à l'intérieur des corps de méthode et autres, par exemple:
/**
* Helper class to store Foo objects inside a bar.
*/
public class Foobar {
/**
* Stores a Foo in this Foobar's bar, unless the bar already contains
* an equivalent Foo.
* Returns the number of Foos added (always 0 or 1).
*/
public int storeFoo(Foo foo) {
// Don't add a foo we already have!
if (this.bar.contains(foo)) {
return 0;
}
// OK, we don't have this foo yet, so we'll add it.
this.bar.append(foo);
return 1;
}
}
Avec un tel style, il est peu probable que vous ayez besoin d'imbriquer des /* */
commentaires (si vous devez désactiver temporairement des méthodes ou des classes entières, les renommer fonctionne tout aussi bien, sinon mieux); et les //
commentaires font nid, au moins avec un peu d' aide de votre IDE.
Enfin, pour désactiver le code, vous disposez d'autres options dans de nombreux langages de programmation; par exemple, en C, vous pouvez tirer parti du préprocesseur:
this_is(activated);
#if 0
this_is(!activated);
/* Comments inside this block don't really nest, they are simply removed
along with the rest of the block! */
#endif
Dans les langages dynamiques, vous pouvez souvent simplement utiliser des if
instructions régulières à la place:
<?php
if (0) {
// This should never run...
some_stuff_that_should_never_run();
}
Cependant, contrairement à l'exemple CPP, cette stratégie nécessite que le fichier source dans son ensemble soit syntaxiquement valide, il n'est donc pas aussi flexible.
Et enfin, il existe au moins quelques langues qui permettent des commentaires imbriqués. Si vous êtes intéressé, wikipedia a un joli tableau de comparaison .