พูดได้หลายภาษาเป็นโปรแกรมที่สามารถทำงานใน 2 หรือมากกว่าการเขียนโปรแกรมภาษาที่แตกต่างกัน

คุณมีเคล็ดลับทั่วไปอย่างไรในการสร้างรูปหลายเหลี่ยมหรือเลือกภาษาที่ง่ายต่อการเขียนรูปหลายเหลี่ยมสำหรับงานเฉพาะ

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

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

ใช้ประโยชน์จากสัญลักษณ์ความคิดเห็น

วิธีง่าย ๆ ในการสร้างสองภาษาสองภาษาคือการแบ่งรหัสออกเป็นสองส่วนดังนี้:

1. ส่วนแรกทำงานจริงในภาษา A ไม่เป็นอันตรายในภาษา B (ไม่มีข้อผิดพลาด) และสิ้นสุดในสัญลักษณ์ความคิดเห็นภาษา A ซึ่งซ่อนส่วนที่สองเป็นภาษา A
2. ส่วนที่สองทำงานจริงในภาษา B

ดังนั้น

• ภาษา A เห็นส่วนแรกซึ่งทำงานและแสดงความคิดเห็น
• ภาษา B เห็นส่วนแรกที่ไร้ประโยชน์แล้วส่วนที่สองซึ่งทำงาน

ส่วนที่ยากเพียงอย่างเดียวที่นี่คือการหาชุดของข้อความ (ส่วนแรก) ที่ทำงานในภาษา A ในขณะที่ไม่ให้ข้อผิดพลาดในภาษา B คำแนะนำบางอย่างสำหรับสิ่งนี้:

• ภาษาสแต็กส่วนใหญ่อนุญาตให้แสดงเฉพาะด้านบนสุดของสแต็คเมื่อสิ้นสุดโปรแกรม (บางครั้งนี่อาจเป็นค่าเริ่มต้นเช่นเดียวกับใน 05AB1E)
• บางภาษาไม่สนใจข้อความที่ไม่ได้กำหนด (ตัวอย่างเช่น Golfscript)

ตัวอย่างง่ายๆที่ใช้แนวทางเหล่านี้สามารถพบได้ที่นี่ ภาษา A และ B มีMATLและ05AB1Eตามลำดับ

ใช้ภาษาสองมิติ

ต่างจากภาษาหนึ่งมิติซึ่งโดยทั่วไปจะแยกวิเคราะห์รหัสที่มาทั้งหมดและจะสร้างข้อผิดพลาดทางไวยากรณ์หรือเอฟเฟกต์รันไทม์ที่ไม่ต้องการในสิ่งที่พวกเขาไม่เข้าใจ (ดังนั้นบังคับให้คุณซ่อนรหัสภาษาอื่น ๆ จากพวกเขา) ภาษาสองมิติ แยกวิเคราะห์รหัสในเส้นทางของการดำเนินการซึ่งหมายความว่าส่วนที่เหลือทั้งหมดของโปรแกรมจะถูกละเว้น นอกจากนี้ยังมีพื้นที่มากขึ้นในการแยกเส้นทางการดำเนินการออกจากกันในสองมิติ คุณสามารถส่งตัวชี้คำแนะนำไปในทิศทางที่ผิดปกติเช่นลงหรือแม้กระทั่งไปทางซ้าย (ล้อมรอบไปทางด้านขวามือของโปรแกรม) เพื่อให้มันออกไปอย่างรวดเร็ว เทคนิคที่มีประโยชน์ในภาษาหนึ่งมิติยังทำให้ภาษาเป็นสองมิติ (เช่นคุณสามารถข้ามรหัสด้วย;; ใน Befunge-98 นอกเหนือจากเพียงแค่การส่ง IP ในทิศทางที่แปลก) ทำให้สิ่งนี้ส่วนใหญ่เป็นเพียงผลกำไรที่เข้มงวดเมื่อเทียบกับโซลูชันหนึ่งมิติ

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

รู้ว่าจริงและเท็จ

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

ตัวอย่างหนึ่งจาก Trick หรือ Treat thread ใช้''เป็นสตริงว่าง ใน Lua สิ่งนี้จะประเมินความจริง แต่เป็นเท็จใน Python ดังนั้นต่อไปนี้:

print(''and'trick'or'treat')

.. จะพิมพ์สตริงที่แตกต่างกันในแต่ละภาษา

สิ่งที่ต้องทำคือหาค่าเช่นนี้ ตัวอย่างเช่นคุณสามารถใช้'0'ซึ่งประเมินเป็นfalsePHP แต่เป็นtruePython

Blockquotes อย่างน้อยหนึ่งภาษา

นี่คือตัวอย่างที่ใช้งานได้ทั้งใน Python และ C ++

#include <iostream> /*
""" */
int main() {
    std::cout << "Hello World!\n";
}

/* """
print("Hello World!")
# */

หลุยส์เมนโดพูดถึงสิ่งที่ฉันคิดว่าเป็นทางออกที่ง่ายที่สุดซึ่งก็คือการใช้ความคิดเห็น

คุณมองหาหนึ่งภาษาที่มีการบล็อกความคิดเห็นและภาษาอื่นที่ไวยากรณ์ปกติในครั้งแรกคือการแสดงความคิดเห็นไวยากรณ์ในที่สอง

ง่ายยิ่งขึ้นคือสองภาษาที่มีสไตล์การแสดงความคิดเห็นบล็อกที่แตกต่างกันซึ่งมีการแก้ไขไวยากรณ์ได้ แต่ฉันไม่สามารถตรวจสอบได้

ลองใช้งานในPython 3.5และC ++

หารและพิชิต

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

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

• มองหาโอกาสในการแยกภาษาเดียวหรือกลุ่มของภาษาที่คล้ายคลึงกันออกจากกัน ทำงานจากกลุ่มใหญ่ไปจนถึงกลุ่มเล็ก เมื่อคุณมีกลุ่มของภาษาที่คล้ายกันทั้งหมด ณ จุดหนึ่งในโปรแกรมคุณจะต้องแยกพวกเขาออกในบางจุด ในช่วงเริ่มต้นของโปรแกรมคุณอาจจะพูดว่าต้องการแบ่งภาษาที่ใช้#เป็นเครื่องหมายความคิดเห็นออกจากภาษาที่ใช้เครื่องหมายความคิดเห็นอื่น ๆ ในภายหลังคุณอาจมีจุดที่ทุกภาษาใช้f(x)ไวยากรณ์สำหรับการเรียกใช้ฟังก์ชันแยกคำสั่งด้วยเครื่องหมายอัฒภาคและมีความคล้ายคลึงกันทางไวยากรณ์ที่คล้ายกัน ณ จุดนี้คุณสามารถใช้ภาษาเฉพาะอื่น ๆ อีกมากมายเพื่อแยกพวกเขาเช่นความจริงที่ว่า Ruby และ Perl ไม่ประมวลผลลำดับการ''ยกเว้นในสตริง แต่ Python และ JavaScript ทำ

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

ตัวอย่างที่ดีคือชุด {JavaScript, Ruby, Perl, Python 3}; ภาษาทั้งหมดเหล่านี้ยอมรับการเรียกใช้ฟังก์ชันด้วยเครื่องหมายวงเล็บและสามารถแยกข้อความสั่งด้วยเครื่องหมายอัฒภาคได้ พวกเขาทั้งหมดยังสนับสนุนevalคำสั่งที่มีประสิทธิภาพช่วยให้คุณสามารถควบคุมการไหลในแบบพกพา (Perl เป็นภาษาที่ดีที่สุดในการแยกออกจากกลุ่มก่อนเพราะมีไวยากรณ์แตกต่างกันสำหรับตัวแปรจากคนอื่น ๆ )

ซ่อนรหัสภายในตัวอักษรของสตริง

ในภาษาส่วนใหญ่สตริงตัวอักษรของมันจะไม่ทำอะไรเลยหรือทำสิ่งที่สามารถย้อนกลับได้ง่าย (เช่นการกดสตริงลงบนสแต็ก) สตริงตัวอักษรไวยากรณ์ยังค่อนข้างไม่มาตรฐานโดยเฉพาะอย่างยิ่งสำหรับไวยากรณ์ทางเลือกที่หลายภาษาใช้ในการจัดการกับสตริงที่มีการขึ้นบรรทัดใหม่; ตัวอย่างเช่นงูหลามมี""" ... """, Perl มีq( ... )และ Lua [[ ... ]]มี

มีการใช้งานหลักสองประการดังนี้ หนึ่งคือการอนุญาตให้คุณ interleave ส่วนที่มีไว้สำหรับภาษาที่แตกต่างกันผ่านการเริ่มต้นสตริงในตอนท้ายของส่วนแรกของภาษาหนึ่งและกลับมาทำงานต่อที่จุดเริ่มต้นของสอง: มันควรจะค่อนข้างง่ายเพื่อหลีกเลี่ยงการปิดสตริงโดยไม่ตั้งใจ ตัวคั่นสตริงระหว่างภาษาต่างๆ อีกอย่างคือตัวคั่นสตริงจำนวนมากมีความหมายเป็นคำสั่งในภาษาอื่น (มักจะมากกว่าเครื่องหมายความคิดเห็น) ดังนั้นคุณสามารถทำสิ่งที่ชอบx = [[4] ]ซึ่งเป็นการมอบหมายที่ไม่เป็นอันตรายในภาษาที่ใช้สัญกรณ์ JSON สำหรับรายการ แต่สิ่งที่เริ่มต้น สตริงใน Lua (และช่วยให้คุณสามารถแยกรหัส Lua จากส่วนที่เหลือเนื่องจากว่ามันมีประสิทธิภาพ "ข้าม" ไปยังถัดไป]])

จบโปรแกรม

คุณสามารถวางโปรแกรมในภาษาหนึ่งได้ในทันทีเพื่อที่จะไม่สนใจโค้ดในภาษาอื่น

ดังนั้นโดยทั่วไปรูปแบบนี้สามารถใช้ได้

code_in_language1 end_program_in_language1 code_for_language2 end_program_in_language2 ...

โดยที่end_program_in_languageNคำสั่งสำหรับสิ้นสุดโปรแกรม

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

"turkey"e#"corn"??"gravy"p&Ssalad
"turkey"e#"corn"??"gravy"                 
                         p&            # print stack and exit program (Dip) 
                           Ssalad      # Now that the program ended in Dip,
                                       # I can write V code that would otherwise
                                       # have caused errors in Dip

แต่ไม่ใช่ทุกภาษาที่มีคำสั่งที่สามารถจบโปรแกรมเช่นนั้นได้ อย่างไรก็ตามหากภาษาดังกล่าวมีคุณสมบัติควรใช้อย่างชาญฉลาด

ตามที่ @LuisMendo แนะนำคุณสามารถสร้างข้อผิดพลาด (ถ้าได้รับอนุญาต) เพื่อจบโปรแกรมหากภาษานั้นยังไม่มี "end program"

ตัวแปรหรือรหัสภายในตัวอักษรของสตริง

ตัวอักษรสตริงที่มีเครื่องหมายคำพูดคู่นั้นไม่เป็นอันตรายในหลายภาษา แต่ในบางภาษาพวกเขาอาจมีรหัส

ใน Bash คุณสามารถใช้`...`(มันไม่ได้จบโปรแกรม):

"`echo Hello world! >/proc/$$/fd/1`"

ใน Tcl คุณสามารถใช้[...]:

"[puts {hello world!};exit]"

ใน PHP คุณสามารถใช้${...}(สิ่งนี้สร้างข้อผิดพลาดใน Bash ดังนั้นมันจะต้องปรากฏหลังจากรหัส Bash):

"${die(print(Hello.chr(32).world.chr(33)))}";

ใน Ruby คุณสามารถใช้#{...}:

"#{puts 'Hello world!';exit}"

อาจมีคนอื่นด้วย

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

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

นามแฝงตัวแปร

นี่อาจเป็นหนึ่งในเทคนิคที่สำคัญที่สุดที่ง่ายที่สุด (IMO) ที่จะใช้โดยเฉพาะอย่างยิ่งเนื่องจากสามารถเข้าถึงหลายภาษาได้

ตัวอย่าง:

print=alert;print("Hello World!")

สิ่งนี้จะใช้ได้กับ Javascript เท่านั้น แต่ยังสามารถใช้กับ Python, Ruby และตัวอย่างอื่น ๆ ได้ในภายหลังเมื่อฉันนึกถึงคนอื่น แน่นอนข้อเสนอแนะความคิดเห็น / การแก้ไขโพสต์ยินดี

#ตามความคิดเห็น

^{เคล็ดลับนี้เป็นส่วนหนึ่งของการใช้ประโยชน์จากสัญลักษณ์ความคิดเห็นและBlockquotes อย่างน้อยหนึ่งภาษา}

เมื่อสร้างรูปหลายภาษาที่มีหลายภาษาโดยเฉพาะอย่างยิ่งภาษาที่พร้อมใช้งานจริงซึ่งต่างจากภาษา esolangs มันจะมีประโยชน์ในการดูภาษาที่ใช้#ในการบล็อกหรือความคิดเห็นบรรทัดเดียว

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

นี่คือรายการสรุปย่อของภาษาที่ใช้#ในความคิดเห็นแบบบล็อก (ไม่ใช่แบบละเอียด):

Language            Start       End      Single-line #?     Notes
------------------------------------------------------------------------------------------
Agena               #/          /#             ✓
AutoIt              #cs         #ce
Brat                #*          *#             ✓
C                   #if 0       #endif                      Not actually a comment
CoffeeScript        ###         ###            ✓            Needs to be on separate line
Common Lisp         #|          |#
Julia               #=          =#             ✓
Lily                #[          ]#             ✓
Objeck              #~          ~#             ✓
Perl 6              #`{         }#             ✓            Any bracketing chars will do
Picolisp            #{          }#             ✓
Scheme              #|          |#

สำหรับตัวอย่างเพิ่มเติมโปรดดูรหัส Rosetta

ต่อไปนี้เป็นตัวอย่างที่ง่ายและรวดเร็วตัวอย่าง:

#|
###
#`[

print("Julia")
#=

|#
(format t "Common Lisp")
#|

###
alert("CoffeeScript")
###

]#
say "Perl 6"
#`[

...

# ]# # ### # |# ; =#

ความคลาดเคลื่อนของตัวดำเนินการทางคณิตศาสตร์

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

ตัวอย่างเช่น:

• ^ เป็น bitor XOR ในบางภาษาและยกกำลังคนอื่น ๆ
• / เป็นการหารจำนวนเต็มในบางภาษาและการหารจำนวนจุดลอยตัวในภาษาอื่น ๆ
  • สำหรับภาษาการหารจำนวนเต็ม-1/2มี-1ในบางภาษา (ปัดเศษลง) และ0ในอื่น ๆ (ปัดเศษเป็นศูนย์)
• -1%2อยู่-1ในบางภาษาและ1ในอื่น ๆ
• --x ไม่มีตัวเลือกในบางภาษา (ลบล้างซ้ำซ้อน) และลดหลั่นลงไปในภาษาอื่น ๆ
• 1/0 ให้อนันต์ในบางภาษาและข้อผิดพลาดออกในคนอื่น ๆ
• 1<<64ให้ 0 ในบางภาษา (ล้น) และ36893488147419103232ในอื่น ๆ

ใช้ Brainfuck

การติดตั้งใช้งาน BF แทบทั้งหมดไม่ได้ใช้ตัวอักษรใด+-<>[].,ๆ ซึ่งไม่ได้เกิดขึ้นเพื่อผลประโยชน์ของเรา!

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

นี่เป็นตัวอย่างง่ายๆ:

.+[.+]

การเพิ่มและเอาท์พุท charcode นี้ค่อนข้างมาก "ถาวร" (ขึ้นอยู่กับการตั้งค่ารันไทม์) ตอนนี้ถ้าคุณต้องการเขียนโค้ดแบบสุ่มให้พูดใน JS คุณสามารถทำได้:

x=>"asdf".repeat(+x)[x*Math.random()*2+1|0]

สังเกตว่า JS นั้นถูกหล่อหลอมรอบ ๆ BF อย่างไร

ต้องแน่ใจว่ามันใช้งานได้ดีที่สุดหากคุณเริ่มต้นด้วย BF จริงๆ มันยากกว่าที่จะเริ่มต้นด้วยภาษาอื่นและพยายามรวม BF

ใช้ภาษาที่อักขระส่วนใหญ่ไม่สำคัญ

นี่คือลักษณะทั่วไปของจุด Mama สนุกม้วนเกี่ยวกับ BF esolang ที่ละเว้นอักขระส่วนใหญ่มีประโยชน์มากในรูปหลายเหลี่ยม มีประโยชน์ด้วย: esolang ซึ่งชุดอักขระขนาดใหญ่สามารถใช้แทนกันได้ ตัวอย่างบางส่วน:

• ช่องว่างละเว้นทุกสิ่งที่ไม่ใช่ช่องว่างแท็บหรือขึ้นบรรทัดใหม่
• Brain-Flakนั้นไม่สนใจทุกสิ่งนอกจาก()[]{}<>นี้ ( @บางครั้งทำให้เกิดข้อผิดพลาดเมื่อล่ามพยายามแยกวิเคราะห์เป็นการเริ่มต้นของการตั้งค่าสถานะการดีบัก)
• oOo CODEไม่สนใจทุกอย่างยกเว้นตัวอักษร นอกจากนี้ตัวอักษรตัวเล็กทั้งหมดสามารถใช้แทนกันได้เช่นเดียวกับตัวอักษรตัวพิมพ์ใหญ่ทั้งหมด
• Wierdแยกความแตกต่างระหว่างอักขระช่องว่างและไม่ใช่ช่องว่างเท่านั้น
• ในWordyอักขระเครื่องหมายวรรคตอนบางตัวจะถูกละเว้นและตัวอักษรทั้งหมดสามารถใช้แทนกันได้
• ทั้งParentheticและวงเล็บ Hellไม่สนใจทุกสิ่งยกเว้นวงเล็บ

จงระวังความคิดเห็นที่ถูกบล็อกซ้อนกัน

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

ตัวอย่างเช่นพิจารณาหลายภาษานี้:

#[#[]#print("Lily")#]#echo"Nim"

ทั้ง Nim และ Lily ใช้#[และ]#เพื่อเริ่มต้นและสิ้นสุดข้อคิดเห็นบล็อก แต่เฉพาะ Nim เท่านั้นที่อนุญาตให้แสดงความคิดเห็นแบบซ้อน

ลิลี่พิจารณาที่สอง#[เป็นส่วนหนึ่งของความคิดเห็นบล็อกเอกพจน์และเป็นครั้งแรก]#ที่สิ้นสุดความคิดเห็นบล็อก ( #คำสั่งการพิมพ์ของ Lily ต่อไปนี้เป็นความคิดเห็นบรรทัดที่ซ่อนรหัสของ Nim)

ไม่เช่นนั้นจะเห็น#[]#ความคิดเห็นบล็อกแบบซ้อน (แม้ว่าจะว่างเปล่า) และprint("Lily")#เป็นความคิดเห็นบล็อกด้านนอก

ไม่แน่ใจว่าสิ่งนี้นับ แต่ ...

ใช้เส้น Shebang เพื่อเปลี่ยนทุกอย่างให้เป็นperlโปรแกรมที่ถูกต้อง

ตามคำตอบนี้และเอกสารประกอบของ Perl หากคุณส่งไฟล์ใด ๆ ที่ขึ้นต้นด้วยบรรทัด shebang ไปให้perlเรียกใช้โปรแกรมที่เหมาะสมเพื่อเรียกใช้ ตัวอย่างเช่นสิ่งนี้

#!/usr/bin/python

for i in range(6):
    print i**2

perl filename.pyได้รับการดำเนินการโดยล่ามหลามถ้าคุณโทร

เรียกใช้ฟังก์ชันที่ไม่มีอยู่แล้วออกจากขณะที่ประเมินอาร์กิวเมนต์

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

identifier(1 + 1)

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

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

ต่อไปนี้เป็นตัวอย่างรูปแบบ dc / Lua:

c2pq(1 + #os.exit(print(3)))

c2pqเป็นโปรแกรม dc ที่จะพิมพ์ 2 และออก; Lua เห็นว่านี่เป็นชื่อของฟังก์ชัน แต่ Lua สามารถป้องกันไม่ให้เกิดข้อผิดพลาดผ่านการวางคำสั่ง exit ในอาร์กิวเมนต์ ข้อได้เปรียบที่ยิ่งใหญ่ของสิ่งก่อสร้างนี้คือไม่เหมือนกับการมอบหมาย ( c2pq =) มันไม่เข้ากันโดยอัตโนมัติกับภาษาที่ชื่อตัวแปรขึ้นต้นด้วย sigil ไวยากรณ์ชื่อฟังก์ชันมีความสอดคล้องกันมากในภาษาต่างๆกว่าไวยากรณ์ชื่อตัวแปรคือ