Comment résoudre le problème des commentaires imbriqués

Il n'apparaît pas dans une seule langue que les commentaires ne peuvent pas être imbriqués. Avez-vous une bonne solution à ce problème? Une solution de contournement en C / C ++ et Java consiste à utiliser uniquement le commentaire sur une seule ligne, mais il devient alors impossible de commenter un bloc plus grand. Je fais face à quelque chose comme ça:

</li><!--
                <li><!-- Save -->

Je dois donc parcourir et modifier manuellement les commentaires. Pouvez-vous nous dire comment nous devons gérer cela, dans de nombreuses langues? Je ne suis pas sûr, mais peut-être que python a une solution pour cela avec la '''manière qui pourrait être en mesure d'inclure un #commentaire en python? "

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 ifinstructions 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 .

C et C ++ ont un commentaire de bloc imbriqué:

#if 0
#endif

De nombreux éditeurs de mise en évidence comprennent cela comme un commentaire et beaucoup d'autres le mettront en surbrillance comme tout autre code désactivé conditionnellement.

Dans de nombreuses autres langues, vous devez compter sur le support de l'éditeur. Pour les langages qui n'ont que des commentaires basés sur des lignes (perl, python, ruby, shell ...), il est plutôt simple d'ajouter le caractère de commentaire à toutes les lignes d'une plage, de sorte que la plupart des éditeurs peuvent le faire. Vous pouvez toujours dire quels étaient les commentaires avant de commenter tout le bloc parce que le caractère de commentaire est doublé - le faire est tout simplement un avantage ici.

XML et SGML est probablement la plus grande douleur, sa définition de commentaire est tout simplement stupide. Les commentaires auraient été insignifiants à imbriquer, mais ils ne le font pas seulement, il est complètement interdit d'avoir un --commentaire intérieur. Malheureusement, je ne sais pas quels éditeurs ont un bon support pour commenter SGML / XML.

Bien qu'il ne s'agisse pas d'une solution générale, et certainement pas idéale, une façon de résoudre ce problème particulier consiste à utiliser le langage de traitement de modèle côté serveur pour faire des commentaires de bloc pour les éléments de commentaire de code imbriqués. Cela laisse le contenu essentiellement intact, mais empêche de l'envoyer au navigateur client.

Cela n'aide pas beaucoup si le fichier est autrement un contenu pur et simple qui ne nécessite aucun autre traitement côté serveur. Dans ce cas et dans le cas plus général des commentaires imbriqués, demandez pourquoi voulez-vous faire cela. Dans la plupart de ces cas, on pourrait trouver que la meilleure façon de le gérer est de ne pas tout gérer. En d'autres termes, si vous souhaitez supprimer une section, supprimez-la, et laissez le contrôle de version gérer la mémorisation des différences si cette section en tant qu'artefact doit être ressuscitée.

Dans le cas HTML / XML, vous pouvez utiliser une instruction de traitement inexistante: voir ma réponse sur SO

<?ignore
  <band height="20">
    <staticText>
      <reportElement x="180" y="0" width="200" height="20"/>
      <text><![CDATA[Hello World!]]></text>
    </staticText>
  </band>
?>
</detail>

Swift prend en charge les commentaires imbriqués. Ainsi, "il n'apparaît pas dans une seule langue que les commentaires ne peuvent pas être imbriqués" n'est plus une véritable déclaration. Si vous n'êtes pas satisfait du manque de prise en charge des commentaires imbriqués dans votre langage de programmation, je vous suggère d'essayer Swift.

/* This is the start of the first multiline comment.
 /* This is the second, nested multiline comment. */
 This is the end of the first multiline comment. */

Langage de programmation Swift: les bases

Le langage de programmation D contient des commentaires imbriqués intégrés:

/+ This is a nested comment 
  /+ This is part of that a comment +/
  /* So is this */
+/
/+ /* This is another nested comment */ +/
/* /* This is not a nested comment */

En d' autres termes, /+et +/nid de commentaires.