วิธีแก้ปัญหาความคิดเห็นซ้อน

ปรากฏเป็นภาษาเดียวที่ไม่สามารถซ้อนความคิดเห็นได้ คุณมีทางออกที่ดีสำหรับปัญหานี้หรือไม่? วิธีแก้ปัญหาหนึ่งใน C / C ++ และ Java คือการใช้ความคิดเห็นบรรทัดเดียวเท่านั้น แต่มันเป็นไปไม่ได้ที่จะแสดงความคิดเห็นบล็อกขนาดใหญ่ ฉันกำลังเผชิญกับสิ่งนี้:

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

ดังนั้นฉันต้องผ่านและแก้ไขความคิดเห็นด้วยตนเอง คุณช่วยแนะนำได้ไหมว่าเราควรจัดการเรื่องนี้ในหลาย ๆ ภาษา? ฉันไม่แน่ใจ แต่หลามอาจมีวิธีแก้ปัญหานี้ด้วย'''วิธีที่อาจรวมถึง#ความคิดเห็นในหลาม? `

ทางออกที่ดีที่สุดคือเห็นได้ชัดว่าไม่ใช่ความคิดเห็นของคุณ ความคิดเห็นแบบซ้อนมักเป็นสัญญาณว่าคุณกำลังใช้ความคิดเห็นที่ไม่ถูกต้อง ตัวอย่างที่พบบ่อยที่สุดคือรหัสใส่ความคิดเห็นที่มีความคิดเห็นอยู่และการแก้ไขคือการลบรหัสแทนการแสดงความคิดเห็น

ดังกล่าวว่าภาษาการเขียนโปรแกรมจำนวนมากมีไวยากรณ์ความคิดเห็นมากกว่าหนึ่งประเภทและคุณสามารถใช้ความจริงนี้เพื่อซ้อนอย่างน้อยหนึ่งระดับ ตัวอย่างเช่นใน Java:

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

นอกจากนี้ในหลายภาษาความคิดเห็นอย่างน้อยหนึ่งประเภทนั้นเป็นแบบซ้อนได้ ในภาษาที่เหมือนกับ C ความคิดเห็นของบรรทัดภายในความคิดเห็นของบรรทัดจะถูกละเว้น:

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

IDEs ส่วนใหญ่สนับสนุนการแสดงความคิดเห็นบล็อกทั้งหมดของรหัสที่มีความคิดเห็นสายในการกระทำเดียวและพวกเขาจัดการสไตล์การแสดงความคิดเห็นชนิดนี้ได้อย่างถูกต้อง ตัวอย่างเดียวกันใน Python:

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

บ่อยครั้งที่การเข้ารหัสมาตรฐานสำหรับโปรเจ็กต์หนึ่งมีกฎเกี่ยวกับสไตล์ความคิดเห็นที่จะใช้เมื่อ; การประชุมทั่วไปคือการใช้ความคิดเห็นที่ถูกบล็อก ( /* */) สำหรับวิธีการและเอกสารประกอบชั้นเรียนและความคิดเห็นแบบอินไลน์ ( //) สำหรับข้อสังเกตภายในเนื้อความของวิธีการและเช่น:

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

ด้วยสไตล์ดังกล่าวจึงไม่น่าเป็นไปได้ที่คุณจะต้องซ้อน/* */ความคิดเห็น (ถ้าคุณต้องปิดใช้งานเมธอดหรือคลาสทั้งหมดเป็นการชั่วคราว และ//ความคิดเห็นทำรังอย่างน้อยด้วยความช่วยเหลือเล็กน้อยจาก IDE ของคุณ

สุดท้ายเพื่อปิดการใช้งานรหัสคุณมีตัวเลือกอื่น ๆ ในภาษาการเขียนโปรแกรมจำนวนมาก ตัวอย่างเช่นใน C คุณสามารถใช้ประโยชน์จากตัวประมวลผลล่วงหน้า:

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

ในภาษาแบบไดนามิกคุณสามารถใช้ifคำสั่งปกติแทน:

<?php

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

อย่างไรก็ตามไม่เหมือนตัวอย่าง CPP กลยุทธ์นี้ต้องการไฟล์ต้นฉบับโดยรวมว่ามีความถูกต้องทางไวยากรณ์ดังนั้นจึงไม่ยืดหยุ่นเท่าที่ควร

และสุดท้ายมีภาษาอย่างน้อยบางภาษาที่อนุญาตให้มีความคิดเห็นซ้อนกัน ในกรณีที่คุณสนใจ, วิกิพีเดียมีกราฟเปรียบเทียบที่ดี

C และ C ++ มีความคิดเห็นบล็อกซ้อนกัน:

#if 0
#endif

บรรณาธิการที่เน้นสีหลายคนเข้าใจว่านี่เป็นความคิดเห็นและอย่างน้อยคนอื่น ๆ จะเน้นว่ามันเป็นรหัสที่ปิดการใช้งานตามเงื่อนไขอื่น ๆ

ในภาษาอื่น ๆ อีกมากมายคุณต้องพึ่งพาการสนับสนุนจากบรรณาธิการ สำหรับภาษาที่มีเพียงความคิดเห็นตามบรรทัด (perl, python, ruby, shell ... ) มันค่อนข้างง่ายในการเพิ่มอักขระความคิดเห็นไปยังทุกบรรทัดในช่วงดังนั้นผู้แก้ไขส่วนใหญ่สามารถทำสิ่งนี้ได้ คุณยังสามารถบอกได้ว่าอะไรคือความคิดเห็นก่อนที่จะแสดงความคิดเห็นบล็อกทั้งหมดเนื่องจากตัวอักขระความคิดเห็นเพิ่มเป็นสองเท่าการทำเช่นนั้นเป็นข้อได้เปรียบที่นี่

XML และ SGML น่าจะเป็นสิ่งที่เจ็บปวดที่สุดความหมายของคำจำกัดความคือโง่ ความเห็นจะได้รับน่ารำคาญไปที่รัง แต่พวกเขาไม่เพียง แต่ทำไม่ได้ก็เป็นสิ่งต้องห้ามอย่างสมบูรณ์ที่จะมีการ--แสดงความคิดเห็นภายใน น่าเสียดายที่ฉันไม่ทราบว่าผู้แก้ไขรายใดมีการสนับสนุนที่ดีสำหรับการแสดงความคิดเห็นใน SGML / XML

ในขณะที่ไม่ใช่วิธีแก้ปัญหาทั่วไปและไม่เหมาะอย่างยิ่งวิธีหนึ่งในการแก้ไขปัญหานี้โดยเฉพาะคือการใช้ภาษาการประมวลผลเทมเพลตฝั่งเซิร์ฟเวอร์เพื่อบล็อกความคิดเห็นสำหรับองค์ประกอบความคิดเห็นรหัสซ้อน สิ่งนี้ทำให้เนื้อหายังคงอยู่ แต่จะป้องกันไม่ให้ส่งไปยังเบราว์เซอร์ไคลเอ็นต์

มันไม่ได้ช่วยอะไรมากมายหากไฟล์นั้นตรงและเนื้อหาที่บริสุทธิ์ซึ่งไม่ต้องการการประมวลผลด้านเซิร์ฟเวอร์อื่น ๆ ในกรณีดังกล่าวและกรณีทั่วไปของความคิดเห็นที่ซ้อนกันถามว่าทำไมคุณต้องการทำเช่นนั้น ในกรณีส่วนใหญ่อาจพบว่าวิธีที่ดีที่สุดในการจัดการคือไม่สามารถจัดการได้ทั้งหมด กล่าวอีกนัยหนึ่งถ้าคุณต้องการที่จะกำจัดส่วนแล้วกำจัดมันและปล่อยให้การควบคุมรุ่นจดจำความแตกต่างถ้าส่วนนั้นเป็นสิ่งประดิษฐ์ที่จำเป็นต้องได้รับการฟื้นคืนชีพ

ในกรณี HTML / XML คุณสามารถใช้คำสั่งการประมวลผลที่ไม่มีอยู่: ดูคำตอบของฉันใน SO

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

Swift สนับสนุนความคิดเห็นที่ซ้อนกันดังนั้น "มันจะปรากฏในภาษาเดียวที่ไม่สามารถซ้อนความคิดเห็นได้" ไม่ใช่คำสั่งที่แท้จริงอีกต่อไป หากคุณไม่พึงพอใจกับการขาดการสนับสนุนสำหรับความคิดเห็นซ้อนในภาษาการเขียนโปรแกรมของคุณฉันขอแนะนำให้ลองใช้ 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: พื้นฐาน

ภาษาการเขียนโปรแกรม D มีความคิดเห็นซ้อนอยู่ภายใน:

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

ในคำอื่น ๆ/+และ+/ความคิดเห็นรัง