สวัสดีและยินดีต้อนรับ. ในการบรรยายนี้ ฉันต้องการพูดคุยเกี่ยวกับคำสั่ง switch
เป็นทางเลือกแทนคำสั่ง if แต่มักใช้เฉพาะในบางสถานการณ์เท่านั้น
แต่มีไวยากรณ์ที่ยอดเยี่ยมสำหรับการทำซ้ำในคำสั่ง if ของคุณ
ดังนั้นตัวดำเนินการตามเงื่อนไขและคำสั่ง if than else ทำให้ง่ายต่อการเขียนโปรแกรมที่เลือกระหว่างสองทางเลือก
ง่ายมากที่จะถามคำถามและตัดสินใจ
อย่างไรก็ตาม หลายครั้งที่โปรแกรมจำเป็นต้องเลือกทางเลือกใดทางหนึ่ง
และนี่โดยพื้นฐานแล้วจะเป็น
if else if else if else if else if
มันยุ่งเหยิงเพราะคุณสามารถใช้สิ่งนี้กับ if ได้อย่างชัดเจนเมื่อคุณมีทางเลือกหลายทาง
แต่คุณสามารถมี ifs ได้หลายร้อย มันเลยน่าเบื่อ มีโอกาสผิดพลาดได้ และมันก็แค่เจ็บที่ก้นเท่านั้น
มันเหมือนกับการเขียนโค้ดสำเร็จรูปจำนวนมาก
ดังนั้น ทางเลือกแทนไวยากรณ์นี้และทุกสิ่งที่คุณทำได้ในสวิตช์ที่คุณสามารถทำได้ใน
if
แต่มันสะอาดกว่าและง่ายกว่าและมีประสิทธิภาพมากกว่าด้วย
ดังนั้นเมื่อเปรียบเทียบค่าของตัวแปรกับค่าต่างๆ ได้สำเร็จ ให้ใช้คำสั่ง
switch
และสิ่งนี้หมายความว่าถ้าคุณมีคำสั่ง if แล้วคุณมี else if, else if, else if,
else if, else if, else if, ใช้คำสั่ง switch
ตอนนี้ถ้านิพจน์บูลีนซับซ้อนกว่านี้เล็กน้อย
คุณไม่สามารถใช้คำสั่ง switch คุณสามารถใช้คำสั่ง
switch ได้เฉพาะเมื่อเปรียบเทียบกับค่า เช่น ค่าคงที่
การแสดงออกไม่สามารถซับซ้อนได้
แต่จะสะดวกกว่าและมีประสิทธิภาพมากในการใช้คำสั่ง switch และภาษาส่วนใหญ่ก็มีโครงสร้างนี้เช่นกัน
แล้วเห็นว่าสวยมาก สิ่งหนึ่งที่คุณสังเกตเห็นว่าหลายภาษาจะสร้างขึ้นจากค
หากคุณได้ตั้งโปรแกรมไว้ก่อนที่คุณจะได้เห็นและคุ้นเคยกับโครงสร้างเหล่านี้มากมาย
เนื่องจากแต่เดิมนั้นพวกมันออกมาในภาษา c หรือเป็นภาษาก่อน
นี่คือไวยากรณ์ของคำสั่ง switch คุณมีคีย์เวิร์ดสวิตช์
จากนั้นภายในสวิตช์ คุณมีวงเล็บซ้ายและขวา
ซึ่งก็คือนิพจน์ ดังนั้นมันจึงดูเหมือนคำสั่ง if ที่จุดเริ่มต้น
ยกเว้นแทนที่จะเป็นคีย์เวิร์ด if คุณมีคีย์เวิร์ด switch
จากนั้นคุณมีวงเล็บปีกกาซ้าย
วงเล็บด้านซ้ายที่จำเป็น วงเล็บด้านซ้ายนั้นเริ่มเนื้อหาของสวิตช์
และคุณเห็นวงเล็บเหลี่ยมด้านขวาสิ้นสุดที่ด้านล่างสุด ที่ปิดส่วนเนื้อหาของสวิตช์
สิ่งสำคัญอีกอย่างที่นี่คือกรณีคีย์เวิร์ดเหล่านี้
กรณีเป็นจริงเช่นคำสั่ง
if เอง ดังนั้นสวิตช์จะดูที่นิพจน์จริง
ๆ ไม่ใช่ว่าจำเป็นต้องเป็นจริงหรือเท็จ
สวิตช์อาจเป็นแค่การดูตัวแปรหรืออะไรก็ได้
แล้วมันก็จะประเมินตัวแปรนั้นในคำสั่ง case
ดังนั้น ถ้าค่า 1 เท่ากับนิพจน์
ถ้าค่า n เท่ากับนิพจน์
แต่คุณสามารถดูสิ่งนี้ได้เหมือนกับว่าสวิตช์อยู่ที่ระดับบนสุด
แล้วแต่ละกรณีจะเป็นคำสั่ง if โดยเปรียบเทียบค่ากับนิพจน์ในสวิตช์
ดังนั้นกรณีจึงเป็นคำสำคัญ คุณยังสังเกตเห็นลำไส้ใหญ่หลังกรณี
ดังนั้นคุณจึงมีคดีและจากนั้นคุณมีค่าของคุณ
และภายในนั้น คุณสามารถมีคำสั่งโปรแกรมได้หลายชุด
และในตอนท้าย คุณมีคีย์เวิร์ดตัวแบ่ง นั่นเป็นอีกคำสำคัญ มีคำหลักสามคำที่นี่
จริงๆ แล้วสี่คำ มีคีย์เวิร์ดสวิตช์ คีย์เวิร์ดเคส คีย์เวิร์ดตัวแบ่ง
และคีย์เวิร์ดเริ่มต้นที่ด้านล่าง
ดังนั้นสิ่งเหล่านี้จึงเป็นสิ่งสำคัญที่ควรสังเกต เราจะพูดถึงตัวอย่างโดยละเอียด
แต่คุณสามารถมีกรณีที่แตกต่างกันได้ และอีกครั้ง นี่ก็แค่ทำเหมือน if else if else if else if
ดังนั้นหากค่าหนึ่งเท่ากับนิพจน์ที่เท่ากัน ให้รันโค้ด
มิฉะนั้น ถ้าค่าที่สองเท่ากับนิพจน์
ให้ประเมินว่า มิฉะนั้น ถ้าค่าสามเท่ากับนิพจน์ ให้ประเมินว่า
มิฉะนั้น ถ้าค่า n เท่ากับนิพจน์ ให้รันโค้ดภายในบล็อกนั้น
และบล็อกของคดีเริ่มต้นด้วยเครื่องหมายทวิภาคและจบลงด้วยการแตกหัก
และถ้าคุณไม่มีรอยแยกตรงนั้น
มันจะผ่านกรณีอื่นๆ เราจะพูดถึงเรื่องนั้นอีกครั้ง
และสิ่งสุดท้ายที่สำคัญคือคีย์เวิร์ดเริ่มต้นนี้ โดยพื้นฐานแล้วนี่คือ อย่างอื่น อย่างอื่น
ถ้า อย่างอื่น ถ้า อย่างอื่น ถ้า และ อย่างอื่น ที่ด้านล่าง
ดังนั้นสิ่งนี้จึงถูกกำหนดหากไม่มีกรณีอื่นใดประเมินนิพจน์
มาพูดถึงรายละเอียดบางอย่างที่ฉันพูดถึงกัน
นิพจน์ที่อยู่ในวงเล็บสามารถเปรียบเทียบกับค่าได้สำเร็จ
ดังนั้น อีกครั้ง
ถ้าเรากลับไปที่ไวยากรณ์ นิพจน์จะถูกเปรียบเทียบกับค่าทั้งหมด
และถ้ามันเท่ากับค่าใด ๆ คุณรันโค้ดภายในค่านั้น
กรณีต้องเป็นค่าคงที่อย่างง่ายหรือนิพจน์คงที่ นิพจน์ที่ประเมินเป็นค่าคงที่
คุณจึงเปิด x บวก y ได้เพราะถ้า x
เป็น 5 นั่นก็แค่เปิด 10 และมันจะเปรียบเทียบค่ากับ 10
แต่โดยปกติ คุณเปิดตัวแปรที่เท่ากับตัวเลขบางตัว
หากพบเคสที่มีค่าเท่ากับค่าของนิพจน์ คำสั่งที่ตามหลังเคสจะถูกดำเนินการ
เมื่อมีมากกว่าหนึ่งคำสั่ง ไม่จำเป็นต้องปิดภายในวงเล็บปีกกา
นั่นก็หมายความว่าเมื่อมีมากกว่าหนึ่งคำสั่งรวม
ไม่จำเป็นต้องมีวงเล็บปีกกาสำหรับคำสั่งกรณี
จำไว้ว่าสำหรับคำสั่ง if เราจะต้องจัดฟันแบบนั้นเสมอ
ซึ่งไม่ใช่กรณีนี้ คุณสามารถวางมันไว้หนึ่งบรรทัดต่อกัน กุญแจสำคัญคือตัวแบ่งที่นั่น
คำสั่ง break ส่งสัญญาณการสิ้นสุดของกรณีเฉพาะและทำให้การดำเนินการของคำสั่งสิ้นสุดลง
มันกระโดดออกไป
หากคุณไม่มีช่องว่าง คดีต่อไปก็จะผ่านไป
ดังนั้นคุณจึงต้องการรวมจุดสิ้นสุดคำสั่งแบ่งของทุกกรณี เมื่อคุณไม่รวมช่วงพัก มักจะหมายความว่ามีข้อบกพร่องหรือบางอย่าง
เหตุผลเดียวที่คุณต้องการรวมตัวแบ่งคือถ้าคุณมีหลายเงื่อนไขที่คุณต้องการรันโค้ด
ดังนั้นหากคุณมีหลายกรณี
โดยพื้นฐานแล้ว บอกว่านิพจน์คือกรณีนี้
กรณีนี้ หรือกรณีนั้น จากนั้นทำสิ่งเดียวกัน จากนั้น
คุณจะเอาตัวแบ่งออก
ดังนั้นจงระวังตัวแบ่งเพราะตัวแบ่งอาจทำให้เกิดปัญหาไม่ว่าจะมีการดำเนินการบล็อกบางตัวในกรณีถัดไปหรือไม่
กรณีพิเศษที่เป็นทางเลือกพิเศษที่เรียกว่าค่าดีฟอลต์จะถูกดำเนินการหากค่าของนิพจน์ไม่ตรงกับกรณีใด
ๆ มันก็เหมือนกับการล่มสลายที่เกิดขึ้นหากไม่มีกรณีใดเป็นจริง
นี่เป็นตัวอย่างที่ดีที่เรากำลังสร้างสวิตช์เพื่อประเมิน enum
ในกรณีนี้ เรามีประเภท enum ที่เรียกว่า วันทำงาน ซึ่งระบุโดยวันธรรมดาทั้งหมดเท่านั้น
จากนั้นเราก็สร้างตัวแปรประเภท enum วันธรรมดา และตั้งค่าเป็นวันจันทร์ จากนั้นจึงเปิดสวิตช์วันนี้
ดังนั้นขึ้นอยู่กับค่าของวันนี้ ตัวแปร หนึ่งในคำสั่ง
case จะถูกดำเนินการ
ถ้าวันนี้เท่ากับวันอาทิตย์ก็จะพิมพ์วันนี้เป็นวันอาทิตย์แล้วกระโดดออกมา
ถ้าวันนี้เท่ากับวันจันทร์ มันจะพิมพ์วันนี้วันจันทร์แล้วกระโดดออกมา
หากไม่เท่ากันก็จะเข้าสู่กรณีเริ่มต้น
ลองมาดูตัวอย่างนี้ในบล็อคโค้ดกัน
ที่นี่เรามีโค้ดตัวอย่างของเรา และคุณจะเห็นว่าเพราะวันนี้เท่ากับวันจันทร์
กรณีวันจันทร์จะถูกประเมิน และคุณจะเห็นผลลัพธ์ในวันนี้คือวันจันทร์
มาสร้างโค้ดนี้และเรียกใช้กัน และนั่นคือสิ่งที่เราจะเห็น วันนี้เป็นวันจันทร์
เพราะสิ่งที่เกิดขึ้นที่นี่คือวันนี้จะเป็นวันจันทร์ คุณใส่นิพจน์ที่คุณต้องการประเมินตัวแปรวันนี้แล้วประเมินมัน
สิ่งสำคัญที่ต้องจำไว้คือ คุณมีวงเล็บเพื่อเริ่มคำสั่ง
switch ในบรรทัดที่ 16 ในวงเล็บปิดท้ายเพื่อสิ้นสุดชื่อสวิตช์ในบรรทัดที่
29
คุณสามารถมีหลายบรรทัดในแต่ละคำสั่ง case ได้โดยไม่ต้องใช้วงเล็บ
ตอนนี้เรามาดูกันว่าจะเกิดอะไรขึ้นหากเรานำคำสั่งพักออกหลังวันจันทร์
เพราะจำไว้ ตัวแตกจะกระโดดออกจากเคสทันที แต่ถ้าเราลบมันออกไป สิ่งที่จะเกิดขึ้นคือมันจะผ่านไปถึงวันอังคาร
และคุณจะได้เห็น printfs ทั้งสองทำงานสำหรับวันจันทร์ของวันนี้และวันนี้คือวันอังคาร
ตอนนี้เมื่อเรารันโปรแกรม เราจะเห็นว่าวันนี้คือวันจันทร์
วันนี้คือวันอังคาร
นั่นคือความสำคัญของคำสั่งพัก
ตัวแบ่งกระโดดออกมา
ดังนั้นอาจเป็นประโยชน์หากคุณต้องการผลลัพธ์เดียวกันในวันจันทร์และวันอังคาร
ตัวอย่างเช่น บางครั้งคุณจะเห็นคำสั่ง
case แบบนี้ case Tuesday เพราะคุณต้องการผลลัพธ์ที่เหมือนกัน
และไม่สำคัญว่าตัวแปรจะเท่ากับอะไร
ดังนั้น คุณอาจเห็นอะไรแบบนั้น แต่เมื่อคุณมีคำสั่ง case แยกที่มีการดำเนินการต่างกัน
คุณต้องเพิ่มตัวแบ่งนั้นเข้าไป
เราจึงดูเฉพาะวันอาทิตย์ วันจันทร์ และวันอังคารเท่านั้น
จะเกิดอะไรขึ้นหากเราตั้งค่าวันนี้ให้เท่ากับวันอาทิตย์เพราะไม่มีกรณีใดที่จะตรงกันได้
สิ่งที่จะเกิดขึ้นคือ มันจะผ่านค่าเริ่มต้น และมันจะพิมพ์อะไรก็ตาม
ลองเรียกใช้สิ่งนี้อีกครั้ง
และเราเห็นว่าวันนี้เป็นวันอาทิตย์
ขออภัย ตั้งเป็นตัวแปรที่ไม่ถูกต้อง ฉันต้องการตั้งค่าเป็น
สมมุติว่า วันพุธ เรามีกรณีสำหรับวันอาทิตย์
ตอนนี้เราจะเห็นว่าจริง ๆ แล้วมันจะพิมพ์อะไรก็ตามเพราะมันไม่ตรงกับกรณีใด
ๆ
ดังนั้นสิ่งที่คุณต้องทำสำหรับสวิตช์คือจำไวยากรณ์ได้จริงๆ
นิพจน์จะอยู่ในวงเล็บนั่นคือสิ่งที่คุณจะประเมิน
กรณีต้องตรงกับนิพจน์ โดยปกติ คุณกำลังสร้างตัวแปร จึงต้องเป็นค่าคงที่หรือนิพจน์ที่ประเมินเป็นค่าคงที่เฉพาะ
แล้วคุณมีเคสสำหรับแต่ละรายการ แล้วก็เป็นค่าเริ่มต้นทั้งหมด และอย่าลืมแบ่ง
กลับไปคุยกันอีกหน่อยและอีกตัวอย่างหนึ่งของการสร้างสวิตช์กับเคส
ในตัวอย่างนี้จะแตกต่างออกไปเล็กน้อย
สิ่งที่เรากำลังทำอยู่นี้คือ เราได้รับข้อมูลจากผู้ใช้แล้วจึงเปิดใช้งาน
ในตัวอย่างนี้ในฟังก์ชันหลักของเรา มันเริ่มจากการสร้างคู่ลอย
จากนั้นจึงสร้างตัวดำเนินการอักขระ จากนั้นจะขอให้ผู้ใช้ป้อนค่า
ตัวดำเนินการ และค่าที่สอง
และมันใช้ตัวระบุรูปแบบเพื่อแยกแยะ และพวกมันทั้งหมดมีที่อยู่ของเครื่องหมายและ
ขึ้นอยู่กับอักขระที่คุณป้อนสำหรับโอเปอเรเตอร์ ไม่ว่าจะเป็นบวกลบหรือดาว นั่นคือสิ่งที่คุณต้องการรวมไว้ในกรณีสวิตช์ของคุณ
ดังนั้นหากผู้ใช้ป้อนเครื่องหมายบวก
คุณจะเห็นในคอลัมน์ถัดไปนี้ โครงสร้างสวิตช์ ตัวดำเนินการเปิดเครื่อง
มันจะเปรียบเทียบค่าของตัวดำเนินการ ค่าของตัวดำเนินการตัวแปร กับแต่ละคำสั่งของกรณีเหล่านี้
และคุณจะสังเกตเห็นว่าข้อความของกรณีเหล่านี้มีเครื่องหมายคำพูดเดี่ยวอยู่รอบๆ
เนื่องจากเรากำลังเปรียบเทียบอักขระ
ดังนั้น คุณจึงสามารถเปรียบเทียบตัวเลข
ตัวแปรกับค่าคงที่เฉพาะ หรืออักขระกับค่าคงที่เฉพาะได้
และภายในคำสั่งแต่ละกรณี เรากำลังพิมพ์รูปแบบเฉพาะออกมา
ค่าหนึ่งบวกค่าสอง ค่าหนึ่งลบค่าสอง
เรากำลังดำเนินการคำนวณในสิ่งพิมพ์ของเรา
แล้วอีกครั้ง คุณจะเห็นประโยคพักที่สำคัญเหล่านั้นพุ่งออกไป
และมันจำเป็นถ้าคุณไม่อยากจะพลาดกรณีอื่นๆ
คุณยังสังเกตเห็นว่าในกรณีที่คำสั่งสุดท้ายที่มีเครื่องหมายทับตัวหาร
เรามีคำสั่ง if
เราไม่มีวงเล็บล้อมรอบเคสเพราะเราสามารถมีหลายประโยคในแต่ละกรณีโดยไม่มีวงเล็บ
กรณีสุดท้ายที่เราบอกว่าถ้าค่าสองเท่ากับ 0 เรากำลังตรวจสอบเล็กน้อยเพื่อให้แน่ใจว่าเราจะไม่หารด้วย
0
และถ้าเราไม่หารด้วย 0 เราก็จะทำการหารของเราจริงๆ
และในตอนท้ายของคดีนั้น เราก็มีช่วงพักอีกครั้ง
กรณีเริ่มต้นของเรากำลังบอกว่าคุณป้อนโอเปอเรเตอร์ที่เราไม่ทราบวิธีจัดการ
แต่คำสั่ง switch นั้นมีประสิทธิภาพมาก
การเขียนที่รวดเร็วมากเมื่อใดก็ตามที่คุณเปรียบเทียบค่าต่างๆ
กับตัวแปรเฉพาะ จากนั้นคุณต้องการทำสิ่งที่แตกต่างกัน
สิ่งสุดท้ายที่ฉันอยากจะพูดถึงก็คือการกล่าวคำแถลงเกี่ยวกับการตัดสินใจ
มันไม่ใช่คำสั่งตัดสินใจโดยตรง
แต่เป็นการข้ามไปยังบรรทัดอื่นของโค้ด โดยใช้ป้ายกำกับ แต่มีให้ใน
c และนั่นคือเหตุผลที่ฉันอยากจะพูดถึงมัน
คำสั่ง go to มีสองส่วนคือ label และ go to keyword
สำหรับบรรดาของคุณที่เคยตั้งโปรแกรมมาก่อนใน
Fortran หรือภาษาพื้นฐานอื่นๆ คุณอาจจะรู้จักสิ่งนี้และคุณอาจจะใช้มันค่อนข้างน้อย
ตอนนี้มาถึง c ไม่จำเป็นต้องใช้มันจริงๆ
มีบางกรณีที่ฉันเห็นว่ามันมีประโยชน์มาก
ซึ่งฉันจะอธิบายในอีกสักครู่ แต่การไปที่นั้นเป็นการข้ามไปที่โค้ดบางส่วน และคุณสามารถไปที่บรรทัดใดก็ได้ของโค้ด
สาเหตุหนึ่งที่คนไม่ชอบใช้มันเพราะมันยากมากที่จะปฏิบัติตาม
เมื่อคุณดูแลโปรแกรมและถ้ามันเป็นแบบต่อเนื่อง คุณจะไปทีละบรรทัด
ถ้าคำสั่งใน while วนซ้ำ
ไม่ดีพอเมื่อคุณมีคำสั่ง if ในลูป while
แต่ตอนนี้ถ้าคุณมีบางอย่างโดยพื้นฐานแล้วคุณอยู่ในบรรทัดที่ 27 ของซอร์สโค้ดของคุณ
และคุณจะข้ามไปที่บรรทัดที่ 800 โดยไม่มีเหตุผลอื่นใดนอกจากแค่ไปที่คีย์เวิร์ด ทันใดนั้น คุณก็ข้ามโค้ดไปมากมาย
และมันยากมากที่จะรักษาและปฏิบัติตาม
ดังนั้นสองส่วนที่จะไปและชื่อป้ายกำกับ ป้ายกำกับตั้งชื่อตามหลักการเดียวกันสำหรับการตั้งชื่อตัวแปร
อักขระที่เป็นตัวอักษรและตัวเลขคละกัน คุณไม่สามารถเริ่มต้นด้วยตัวเลข คุณสามารถเริ่มต้นด้วยขีดล่าง
คุณสามารถเริ่มต้นด้วยขีดล่าง
โดยพื้นฐานแล้ว คุณเพียงแค่ใช้คีย์เวิร์ด go to และไปที่ตัวระบุบางส่วน
ส่วนที่สอง ส่วนที่สองเป็นฉลากที่ไหนสักแห่ง
ดังนั้นเพื่อที่จะข้ามไปยังบรรทัดของโค้ดนั้นได้ คุณต้องติดป้ายกำกับบรรทัดของโค้ดนั้น
ต้องมีข้อความว่าภาคสอง
ตอนนี้ ผมจะยกตัวอย่างให้คุณเห็น แต่คุณไม่ควรใช้สิ่งนี้เพราะปัญหาที่เกี่ยวข้องกับการบำรุงรักษา
อย่างไรก็ตาม ฉันอยากจะพูดถึงมันหากคุณเคยตั้งโปรแกรมไว้ก่อนหน้านี้และเคยชินกับมันแล้ว
ในค คุณไม่จำเป็นต้องใช้มันมากนัก
มีกรณีการใช้งานหนึ่งที่ฉันเห็นว่าอาจมีประโยชน์
วันก่อนฉันทำงานกับเพื่อนโปรแกรมเมอร์คนหนึ่ง
และเขามีลูปที่ซ้อนกันหลายอันหรือคำสั่งที่ซ้อนกันอยู่
แต่ลูปอาจเป็นตัวอย่างที่ดีกว่าจริงๆ วนซ้ำ จำรหัสซ้ำ เขามีลูปซ้อนกันมากมาย
และในวงที่ซ้อนกันชั้นใน เหมือนกับวงที่ห้า เขาต้องการกระโดดออกจากลูปทั้งหมด
เพราะเขามีอาการบางอย่าง
ดังนั้นเขาจึงเคยกระโดดออกจากลูปเหล่านั้น
อีกวิธีหนึ่งในการออกจากลูปคือการใช้คีย์เวิร์ดเบรก
แต่เบรกจะกระโดดออกจากด้านในสุดเท่านั้น
ดังนั้นจึงไม่มีทางได้ผลจริง ๆ หากไม่มีเขาตั้งแฟล็กจำนวนมากและมีคำสั่ง
if จำนวนมากเพื่อออกจากทุกลูป ดังนั้นเขาจึงเคยไป
และนั่นเป็นกรณีหนึ่งที่ฉันคิดว่ามีประโยชน์มากเพราะมันลดจำนวนโค้ดที่คุณต้องเขียน
และมันค่อนข้างชัดเจนว่าเกิดอะไรขึ้น
คุณเพิ่งกระโดดออกจากลูปที่ซ้อนกันทั้งหมดเพราะคุณพบเงื่อนไขบางอย่าง
และนั่นเป็นกรณีหนึ่ง แต่โดยส่วนใหญ่แล้ว คุณไม่จำเป็นต้องไปจริงๆ
และด้วยเหตุผลที่ฉันพูดถึงว่ามันมีปัญหามาก มันยากที่จะทำตามโค้ดเมื่อคุณกระโดดไปทั่ว
แต่การใช้งานก็เหมือนกับที่คุณใช้มันเหมือนกับที่คุณใช้ในภาษาอื่นๆ
คุณต้องไปที่คีย์เวิร์ดที่มีชื่อป้ายกำกับ
และสิ่งที่จะเกิดขึ้นในโค้ดของคุณก็คือ คุณจะข้ามไปยังโค้ดบรรทัดนั้นที่มีป้ายกำกับ
ดังนั้นคุณจึงสามารถข้ามโค้ดได้ทุกประเภท
ในตัวอย่างนี้ เรามีเลเบลชื่อ top และมีโคลอน
นั่นเป็นวิธีที่คุณรู้ว่าเป็นฉลาก
และด้านบนมีข้อความบางส่วน และที่ด้านล่างสุด
คุณมีคำสั่ง if และคุณบอกว่าถ้าถ่านเท่ากับ y ให้ไปที่ด้านบน
อีกครั้ง คุณจะเห็นว่าคุณสามารถข้ามไปรอบๆ ในโค้ดของคุณได้อย่างไร และนั่นทำให้ยากต่อการติดตามมาก
ดังนั้นอย่าใช้มันโดยพื้นฐาน เว้นแต่ว่าคุณมีลูปที่ซ้อนกันหลายอันและคุณต้องการกระโดดออกจากลูปทั้งหมด
ขอขอบคุณ.