Come risolvere il problema dei commenti nidificati

Non appare in una sola lingua che i commenti non possono essere nidificati. Hai una buona soluzione per questo problema? Una soluzione alternativa in C / C ++ e Java è utilizzare solo il commento a riga singola ma diventa impossibile quindi commentare un blocco più grande. Sto affrontando qualcosa del genere:

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

Quindi devo passare manualmente attraverso e modificare i commenti. Puoi consigliarci come dovremmo gestirlo, in molte lingue? Non sono sicuro, ma forse Python ha una soluzione per questo con il '''modo che potrebbe essere in grado di includere un #commento in Python? `

La soluzione migliore è, ovviamente, semplicemente non annidare i tuoi commenti. I commenti nidificati in genere indicano che si stanno utilizzando commenti errati. L'esempio più comune è il codice commentato che contiene commenti stessi e la correzione è rimuovere il codice invece di commentarlo.

Detto questo, molti linguaggi di programmazione hanno più di un tipo di sintassi di commento e puoi usare questo fatto per annidare almeno un livello in profondità. Ad esempio, in Java:

/* This is commented out!
Foo.bar.baz();
// And now for something completely different...
Quux.runWith(theMoney);
*/

Inoltre, in molte lingue, almeno un tipo di commento è di tipo annidabile; nei linguaggi di tipo C, i commenti di riga all'interno dei commenti di riga vengono ignorati:

// some_commented_out(code);
// // This is a comment inside the comment!
// // Still inside the nested comment.
// some_more_code_in(outer_comment);

La maggior parte degli IDE supporta il commento di interi blocchi di codice con commenti di riga in un'unica azione e gestiscono correttamente questo tipo di stile di commento. Lo stesso esempio in Python:

# some_commented_out(code)
# # This is a comment inside the comment!
# # Still inside the nested comment.
# some_more_code_in(outer_comment)

Spesso, gli standard di codifica per un particolare progetto hanno regole su quale stile di commento usare quando; una convenzione comune consiste nell'utilizzare commenti a blocchi ( /* */) per la documentazione relativa a metodi e classi e commenti incorporati ( //) per osservazioni all'interno degli organismi dei metodi e simili, ad esempio:

/**
 * 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;
    }
}

Con un tale stile, è improbabile che tu abbia mai bisogno di annidare i /* */commenti (se devi disabilitare temporaneamente interi metodi o classi, rinominandoli funzionano altrettanto bene, se non meglio); e //commenti fanno nido, almeno con un piccolo aiuto da vostro IDE.

Infine, per disabilitare il codice, hai altre opzioni in molti linguaggi di programmazione; ad esempio, in C, è possibile sfruttare il preprocessore:

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

In linguaggi dinamici, spesso puoi semplicemente usare ifistruzioni regolari :

<?php

if (0) {
   // This should never run... 
   some_stuff_that_should_never_run();
}

Tuttavia, a differenza dell'esempio CPP, questa strategia richiede che il file sorgente nel suo insieme sia sintatticamente valido, quindi non è molto flessibile.

E infine, ci sono almeno alcune lingue che consentono commenti nidificati. Nel caso tu sia interessato, Wikipedia ha una bella tabella comparativa .

C e C ++ hanno commenti di blocco nidificati:

#if 0
#endif

Molti redattori di evidenziazione lo capiscono come un commento e molti altri lo evidenzieranno almeno come qualsiasi altro codice disabilitato condizionatamente.

In molte altre lingue devi fare affidamento sul supporto dell'editor. Per le lingue che hanno solo commenti basati su linee (perl, python, ruby, shell ...) è piuttosto semplice anteporre il carattere di commento a tutte le righe in un intervallo, quindi la maggior parte degli editor può farlo. Puoi ancora dire quali erano i commenti prima di commentare l'intero blocco perché il carattere del commento è raddoppiato - farlo semplicemente è un vantaggio qui.

XML e SGML sono probabilmente il dolore maggiore, la definizione dei commenti è semplicemente stupida. I commenti sarebbero stati banali da annidare, ma non solo non lo fanno, è completamente vietato avere --commenti interni. Sfortunatamente non so quali editor abbiano un buon supporto per commentare in SGML / XML.

Sebbene non sia una soluzione generale, e certamente non ideale, un modo per affrontare questo particolare problema è utilizzare il linguaggio di elaborazione dei modelli sul lato server per fare commenti a blocchi per gli elementi di commenti di codice nidificati. Ciò lascia il contenuto essenzialmente intatto, ma impedisce di inviarlo al browser client.

Ciò non aiuta molto se il file è contenuto semplice e puro che non richiede altre elaborazioni lato server. In quel caso e nel caso più generale di commenti nidificati, chiedi perché vuoi farlo. Nella maggior parte dei casi, si potrebbe scoprire che il modo migliore per gestirlo è non gestirlo tutto. In altre parole, se si desidera eliminare una sezione, quindi eliminarla e lasciare che il controllo versione gestisca il ricordo delle differenze se quella sezione come artefatto deve mai essere resuscitata.

Nel caso HTML / XML è possibile utilizzare un'istruzione di elaborazione inesistente: vedere la mia risposta su SO

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

Swift supporta i commenti nidificati, pertanto "non appare in una sola lingua in cui i commenti non possono essere nidificati" non è più una vera affermazione. Se non sei soddisfatto della mancanza di supporto per i commenti nidificati nel tuo linguaggio di programmazione, suggerirei di provare 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. */

Swift Programming Language: The Basics

Il linguaggio di programmazione D ha commenti nidificati incorporati:

/+ 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 */

In altre parole, /+e +/nidificano i commenti.