คำสั่งสวิตช์

Q: ตกลงมา

คำสั่ง switch มีสองรูปแบบหลัก ได้แก่ แบบไม่มีโครงสร้าง ซึ่งรองรับการ ทำงานแบบ fall through และ แบบมีโครงสร้าง ซึ่งไม่รองรับ การทำงานแบบ fall through

ในการเขียนโปรแกรมคอมพิวเตอร์คำสั่ง switchเป็น กลไก ควบคุมการไหลของโปรแกรมที่เลือกการทำงานและเปลี่ยนแปลงการควบคุมการทำงานตามค่าของนิพจน์ (เช่น การประเมินค่าตัวแปร ) คำสั่ง switch คล้ายกับคำสั่ง ifแต่แทนที่จะแยกการทำงานเฉพาะเมื่อเป็นจริงหรือเท็จเท่านั้น มันจะแยกการทำงานเมื่อมีค่าใดๆ ก็ได้ แม้ว่าไวยากรณ์จะแตกต่างกันไปตามภาษาโปรแกรม แต่ภาษา เชิง คำสั่ง ส่วนใหญ่จะมีคำสั่งที่มีความหมาย ดังที่อธิบายไว้ในที่นี้ ซึ่งก็คือคำสั่ง switch นั่นเอง มักใช้ คำหลัก `switch` แทนswitchแต่บางภาษาก็ใช้รูปแบบอื่นๆ เช่นcase`switch`, select`switch`, หรือinspect`switch`

ค่า

บางครั้ง การใช้คำสั่ง switch ถือว่าดีกว่าการใช้คำสั่ง if-then-else หลายๆ คำสั่งเรียงกัน เพราะมีเหตุผลดังนี้:

เข้าใจง่ายขึ้น: และด้วยเหตุนี้จึงดูแลรักษาง่ายกว่า: อย่างน้อยก็ในบางส่วน เนื่องจากมีความลึกคงที่

แก้ไขข้อผิดพลาดได้ง่ายขึ้น: ตัวอย่างเช่น การตั้งเบรกพอยต์บนโค้ด เทียบกับการตั้งเบรกพอยต์บนตารางการเรียกฟังก์ชัน ในกรณีที่ดีบักเกอร์ไม่มีความสามารถในการตั้งเบรกพอยต์แบบมีเงื่อนไข

ตรวจสอบได้ง่ายขึ้น: เพื่อให้มั่นใจว่าค่าทั้งหมดได้รับการจัดการ เนื่องจากคอมไพเลอร์อาจแจ้งเตือนหากค่าใดไม่ได้รับการจัดการ

สามารถดำเนินการได้เร็วขึ้น: การ ใช้งาน ที่ได้รับการปรับให้เหมาะสมอาจดำเนินการได้เร็วกว่ามาก เนื่องจากมักจะถูกนำไปใช้ในรูปแบบตารางสาขา^{[ 1 ]}เมื่อนำไปใช้ในลักษณะดังกล่าว คำสั่ง switch จะประกอบด้วยแฮชที่สมบูรณ์แบบ

คอมไพเลอร์ที่ปรับแต่งประสิทธิภาพเช่นGCCหรือClangอาจคอมไพล์คำสั่ง switch เป็นตารางสาขาหรือ การค้นหา แบบไบนารี^{[ 2 ]}ตารางสาขาช่วยให้โปรแกรมสามารถระบุสาขาที่จะดำเนินการด้วยการคำนวณเพียงครั้งเดียว แทนที่จะเปรียบเทียบค่าตามลำดับ การค้นหาแบบไบนารีใช้การเปรียบเทียบเพียงจำนวนลอการิทึม ซึ่งวัดจากจำนวนกรณีในคำสั่ง switch โดยทั่วไป วิธีเดียวที่จะตรวจสอบว่าโค้ดได้รับการปรับแต่งประสิทธิภาพด้วยวิธีนี้หรือไม่ คือการวิเคราะห์เอาต์พุตของคอมไพเลอร์ เช่นแอสเซมบลีหรือรหัสเครื่อง

ซับซ้อนน้อยกว่า: ในแง่ของกราฟควบคุมการไหลคำสั่ง switch ประกอบด้วยโหนดสองโหนด (ทางเข้าและทางออก) บวกกับเส้นเชื่อมระหว่างโหนดทั้งสองสำหรับแต่ละตัวเลือก ในทางตรงกันข้าม ลำดับของคำสั่ง if-then-else จะมีโหนดเพิ่มเติมสำหรับทุกกรณี ยกเว้นกรณีแรกและกรณีสุดท้าย พร้อมกับเส้นเชื่อมที่สอดคล้องกัน กราฟควบคุมการไหลที่ได้จากลำดับของคำสั่ง "if" จึงมีโหนดและเส้นเชื่อมมากกว่าเกือบสองเท่า โดยไม่เพิ่มข้อมูลที่เป็นประโยชน์ใดๆ

องค์ประกอบ

โดยทั่วไป คำสั่ง switch ประกอบด้วย:

กริยา: เริ่มต้นด้วยกริยาควบคุม เช่นselectซึ่งตามด้วยนิพจน์ ซึ่งมักจะเป็นชื่อตัวแปรนิพจน์ควบคุมหรือตัวแปรควบคุม

กรณี: ส่วนทางเลือกของสาขาถัดไปแต่ละส่วนจะเริ่มต้นด้วยคำหลัก (เช่นcase) บวกกับค่า (หรือหลายค่า) พร้อมด้วยโค้ดที่จะดำเนินการสำหรับค่าเหล่านั้น ในบางภาษา เช่นPL/IและRexxหากละเว้นนิพจน์ควบคุม ทางเลือกแต่ละส่วนจะเริ่มต้นด้วยwhenข้อความที่มีนิพจน์บูลีน และการจับคู่จะเกิดขึ้นสำหรับกรณีแรกที่นิพจน์นั้นประเมินค่าเป็นจริง คล้ายกับโครงสร้าง if-then-else

ในภาษาโปรแกรมที่มีพฤติกรรม fall through เช่นภาษา C แต่ละส่วนจะลงท้ายด้วยคำสำคัญ (เช่นbreak) หากส่วนนั้นไม่ ควร fall through

ค่าเริ่มต้น: โดยทั่วไปแล้ว อนุญาตให้มีกรณีเริ่มต้นที่เป็นตัวเลือกได้ ซึ่งมักจะใช้ผ่านคำหลัก เช่น `default` default, `default` otherwiseหรือelse`default` การควบคุมจะไปยังส่วนนี้เมื่อไม่มีกรณีอื่นใดตรงกับนิพจน์ควบคุม ในบางภาษา เช่น C หากไม่มีกรณีใดตรงกันและส่วนเริ่มต้นถูกละเว้น คำสั่งจะไม่ทำอะไรเลย แต่ในภาษาอื่นๆ เช่น PL/I จะเกิดข้อผิดพลาด

ตกลงมา

คำสั่ง switch มีสองรูปแบบหลัก ได้แก่แบบไม่มีโครงสร้างซึ่งรองรับการทำงานแบบ fall throughและแบบมีโครงสร้างซึ่งไม่รองรับ การทำงานแบบ fall through

สำหรับคำสั่ง switch ที่มีโครงสร้าง เช่นใน ภาษาที่คล้ายกับ Pascalการควบคุมจะกระโดดจากจุดเริ่มต้นของคำสั่ง switch ไปยังกรณีที่เลือก และเมื่อสิ้นสุดกรณี การควบคุมจะกระโดดกลับไปยังจุดสิ้นสุดของคำสั่ง switch ลักษณะการทำงานคล้ายกับเงื่อนไข if–then–else แต่รองรับการแยกสาขามากกว่าแค่ค่า true และ false เพื่อให้ค่าหลายค่าสามารถเรียกใช้โค้ดเดียวกันได้ (หลีกเลี่ยงโค้ดซ้ำซ้อน ) ไวยากรณ์จึงอนุญาตให้มีหลายค่าต่อกรณี

คำสั่ง switch ที่ไม่มีโครงสร้าง เช่นในภาษา C (และโดยทั่วไปในภาษาที่ได้รับอิทธิพลจากคำสั่ง goto แบบคำนวณ ของ Fortran ) ทำงานคล้ายกับ คำสั่ง gotoการควบคุมจะแยกจากจุดเริ่มต้นของ switch ไปยังส่วนของ case จากนั้นการควบคุมจะดำเนินต่อไปจนกว่าจะถึงคำสั่ง exit ของบล็อกหรือจุดสิ้นสุดของคำสั่ง switch เมื่อการควบคุมแยกไปยัง case หนึ่ง แต่ยังคงดำเนินต่อไปยังสาขาถัดไป การไหลของควบคุมเรียกว่าfall throughและอนุญาตให้แยกไปยังโค้ดเดียวกันสำหรับหลายค่า

ป้องกันการเกิด fall through โดยการจบเคสด้วยคีย์เวิร์ด (เช่นbreak) แต่ข้อผิดพลาดทั่วไปคือการละเว้นคีย์เวิร์ดโดยไม่ได้ตั้งใจ ทำให้เกิด fall through โดยไม่ตั้งใจและมักจะเป็นบั๊กดังนั้นหลายคนจึงมองว่าคุณลักษณะของภาษานี้เป็นอันตราย^{[ 3 ]} และบ่อยครั้งที่โค้ด fall through ส่งผลให้เกิดคำเตือนจากเครื่องมือ ตรวจสอบคุณภาพโค้ด เช่นlint

บางภาษา เช่นJavaScriptยังคงรักษาความหมายของ fall through ไว้ ในขณะที่ภาษาอื่นๆ ตัดออกหรือจำกัดความหมายนั้น ที่น่าสังเกตคือ ใน C# บล็อกทั้งหมดต้องลงท้ายด้วย `if` breakหรือ `if` returnเว้นแต่บล็อกนั้นว่างเปล่า ซึ่งจำกัดให้ fall through ใช้ได้เฉพาะกับการแยกเงื่อนไขจากค่าหลายค่าเท่านั้น

ในบางกรณี ภาษาต่างๆ อนุญาตให้มีการผ่านขั้นตอนต่อไปได้ ตัวอย่างเช่นPerlจะไม่ผ่านขั้นตอนต่อไปโดยค่าเริ่มต้น แต่ในกรณีหนึ่งอาจทำเช่นนั้นโดยชัดเจนโดยใช้continueคำหลัก ซึ่งป้องกันการผ่านขั้นตอนต่อไปโดยไม่ตั้งใจ ในทำนองเดียวกันBashจะตั้งค่าเริ่มต้นให้ไม่ผ่านขั้นตอนต่อไปเมื่อสิ้นสุดด้วย;;แต่จะอนุญาตให้ผ่านขั้นตอนต่อไป^{[ 4 ]}ด้วย;&หรือ;;&แทน

ตัวอย่างหนึ่งของคำสั่ง switch ที่อาศัย fall through คือDuff 's device

การประเมินการแสดงออกของกรณี

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

ตัวอย่างเช่น ในPHPและRubyค่าคงที่สามารถใช้เป็นนิพจน์ควบคุมได้ และคำสั่ง case แรกที่ประเมินค่าแล้วตรงกับค่าคงที่นั้นจะถูกเรียกใช้งาน ในโค้ด PHP ต่อไปนี้ นิพจน์ switch มีค่าเป็นจริง ดังนั้นนิพจน์ case แรกที่เป็นจริงจะถูกเลือก

switch ( true ) { case ( $x == 'hello' ) : foo (); break ; case ( $z == 'howdy' ) : break ; }

คุณสมบัตินี้ยังมีประโยชน์สำหรับการตรวจสอบตัวแปรหลายตัวเทียบกับค่าเดียว แทนที่จะตรวจสอบตัวแปรเดียวเทียบกับหลายค่า

switch ( 5 ) { case $x : break ; case $y : break ; }

COBOLก็รองรับรูปแบบนี้เช่นกันผ่านEVALUATEทางคำสั่งของมัน PL/I ก็รองรับพฤติกรรมที่คล้ายกันโดยการละเว้นนิพจน์ควบคุม และWHENนิพจน์แรกที่ประเมินค่าได้เป็นจริงจะถูกดำเนินการ

ในภาษา Ruby ด้วยวิธีการจัดการ===ความเท่าเทียมกันของ Ruby ทำให้สามารถใช้คำสั่ง `case` เพื่อทดสอบคลาสของตัวแปรได้ ตัวอย่างเช่น:

ถ้าอินพุตเป็นArray ให้แสดงข้อความ'อินพุตเป็น Array!' ถ้า อินพุตเป็น Hash ให้แสดงข้อความ'อินพุตเป็น Hash!'

ค่าผลลัพธ์

บางภาษาโปรแกรมรองรับการประเมินค่าคำสั่ง switch ให้เป็นค่าอื่น

การแสดงออกของกรณี

การแสดงออกของกรณีได้รับการสนับสนุนโดยภาษาที่มีมาอย่างน้อยตั้งแต่ALGOL-W [ ^{5 ] ใน} ALGOL-W การแสดงออกของจำนวนเต็มจะถูกประเมิน จากนั้นจึงประเมินการแสดงออกที่ต้องการจากรายการของการแสดงออก:

J := กรณีI ของ( 3.14 , 2.78 , 44 8.9 ) ; A := กรณีDECODE ( C ) - 128 ของ( " A " , " B " , " C " , " D " , " E " , " F " ) ;

ภาษาอื่นๆ ที่รองรับการแสดงนิพจน์กรณี (case expression) ได้แก่SQL , Standard ML , Haskell , Common LISPและOxygene

การแสดงออกของสวิตช์

นิพจน์switch (ที่แนะนำในJava SE 12 ) จะประเมินค่าเป็นค่าหนึ่ง นอกจากนี้ยังมีรูปแบบใหม่ของป้ายกำกับเคสcase L->ซึ่งด้านขวามือเป็นนิพจน์เดียว สิ่งนี้ยังป้องกัน fall through และกำหนดให้เคสต้องครอบคลุมทุกเคส ใน Java SE 13 yieldมีการแนะนำคำสั่ง และใน Java SE 14 นิพจน์ switch กลายเป็นคุณสมบัติมาตรฐานของภาษา^{[ 6 ]}^{[ 7 ]}^{[ 8 ]}ตัวอย่างเช่น:

int dayCount = switch ( month ) { case JAN , MAR , MAY , JUL , AUG , OCT , DEC -> 31 ; case APR , JUN , SEP , NOV -> 30 ; case FEB -> { if ( year % 400 == 0 ) { yield 29 ; } else if ( year % 100 == 0 ) { yield 28 ; } else if ( year % 4 == 0 ) { yield 29 ; } else { yield 28 ; } } };

Ruby ก็รองรับความหมายเหล่านี้เช่นกัน ตัวอย่างเช่น:

catfood = case when cat . age <= 1 junior when cat . age > 10 senior else normal end

การจัดการข้อยกเว้น

ภาษาโปรแกรมหลายภาษาใช้รูปแบบของคำสั่ง switch ในการจัดการข้อยกเว้นโดยหากเกิดข้อยกเว้นในบล็อก ระบบจะเลือกสาขาแยกต่างหาก ขึ้นอยู่กับข้อยกเว้นนั้น ในบางกรณี อาจมีสาขาเริ่มต้น (default branch) สำหรับกรณีที่ไม่มีข้อยกเว้นเกิดขึ้น ตัวอย่างแรกๆ คือModula-3ซึ่งใช้ ไวยากรณ์ TRY... EXCEPTโดยแต่ละส่วนEXCEPTกำหนดกรณีต่างๆ นอกจากนี้ยังพบได้ในDelphi , ScalaและVisual Basic .NETด้วย

ตัวอย่าง

ซี

โค้ดต่อไปนี้เป็นคำสั่ง switch ในภาษา C ถ้าageค่าเป็น 1 จะแสดงผล "You're one." ถ้าageค่าเป็น 3 จะแสดงผล "You're three. You're three or four." คำสั่ง switch ในC++ทำงานเหมือนกับในภาษา C

#include <stdio.h>void printAge ( unsigned int age ) { switch ( age ) { case 0 : printf ( "คุณเป็นเด็กแรกเกิด!" ); break ; case 1 : printf ( "คุณอายุ 1 ปี" ); break ; case 2 : printf ( "คุณอายุ 2 ปี" ); break ; case 3 : printf ( "คุณอายุ 3 ปี" ); case 4 : printf ( "คุณอายุ 3 หรือ 4 ปี" ); break ; default : printf ( "คุณอายุมากกว่า 4 ปี!" ); } }

ตั้งแต่เวอร์ชันC2Y เป็นต้นมา คำสั่ง switch รองรับการระบุช่วงของกรณีที่จะดักจับ คุณสมบัตินี้ปรากฏครั้งแรกในฐานะ ส่วนขยาย ของ GCCสำหรับภาษา C

#include <stddef.h> #include <stdio.h> #include <uchar.h>void writeUnicode ( char32_t c ) { switch ( c ) { // ตรงกับค่าใดๆ ระหว่าง [0, 0x7F] รวมทั้งสองค่า กรณี0 ... 0x7F : putchar ( c ); break ; // ตรงกับค่าใดๆ ระหว่าง [0x80, 0x7FF] รวมทั้งสองค่า กรณี0x80 ... 0x7FF : putchar ( 0xC0 + c >> 6 ); putchar ( 0x80 + c & 0x3f ); break ; // ตรงกับค่าใดๆ ระหว่าง [0x800, 0xFFFF] รวมทั้งสองค่า กรณี0x800 ... 0xFFFF : putchar ( 0xE0 + c >> 12 ); putchar ( 0x80 + ( c >> 6 ) & 0x3f ); putchar ( 0x80 + ( c >> 12 )); break ; default : unreachable (); } }

ไพธอน

Python (ตั้งแต่เวอร์ชัน 3.10.6 เป็นต้นไป) รองรับคีย์เวิร์ดmatch`and` ^[⁹^]^[¹⁰^]^[¹¹^]^[¹²^]ไม่อนุญาตให้มีการทะลุผ่าน (fall through) ต่างจากเงื่อนไขของคำสั่ง `if` คีย์เวิร์ด `and` ไม่สามารถใช้เพื่อแยกความแตกต่างระหว่างกรณีต่างๆได้ เทียบเท่ากับ `or` ในภาษา Ccaseorcase _default

letter : str = input ( "ป้อนตัวอักษร: " ) . strip ()[ 0 ] . casefold () match letter : case "a" | "e" | "i" | "o" | "u" : print ( f "ตัวอักษร ' { letter } ' เป็นสระ!" ) case "y" : print ( f "ตัวอักษร ' { letter } ' อาจเป็นสระ" ) case _ : print ( f "ตัวอักษร ' { letter } ' ไม่ใช่สระ!" )

ปาสคาล

ต่อไปนี้เป็นตัวอย่างในภาษาปาสคาล :

ถ้าเป็นอักขระ'a' ให้ดำเนินการกับอักขระ' a' และ'x' ให้ดำเนินการกับอักขระ' x ' และ 'x' ให้ดำเนินการกับอักขระ'y' และ'z' มิฉะนั้นให้ดำเนินการกับอักขระที่ไม่ตรงกัน

ใน ภาษาพาสคาลแบบ Oxygeneคำสั่ง switch สามารถใช้เป็นนิพจน์ได้:

var i : Integer := case someChar of 'a' : 10 ; 'x' : 20 ; 'y' : 30 ; else - 1 ; end ;

สคริปต์เชลล์

ต่อไปนี้เป็นตัวอย่างในสคริปต์เชลล์ :

กรณี$someChar ใน a )ดำเนินการเมื่อ A ; ;; x )ดำเนินการเมื่อ X ; ;; [ yz ])ดำเนินการเมื่อ Y และ Z ; ;; * )ดำเนินการเมื่อไม่พบการจับคู่;; esac

แอสเซมเบลอร์

คำสั่ง switch ในภาษาแอสเซมบลี :

switch: cmp ah , 00h je a cmp ah , 01h je b jmp swtend ; ไม่มีกรณีใดตรงกันหรือมีรหัส "ค่าเริ่มต้น" ที่นี่a: push ah mov al , 'a' mov ah , 0Eh mov bh , 00h int 10h pop ah jmp swtend ; เทียบเท่ากับ "break" b: push ah mov al , 'b' mov ah , 0Eh mov bh , 00h int 10h pop ah jmp swtend ; เทียบเท่ากับ "break" ... swtend:

ทางเลือกอื่นๆ

ทางเลือกอื่นนอกเหนือจากการใช้คำสั่ง switch ได้แก่:

ถ้า-แล้ว-มิฉะนั้น: ชุดคำสั่ง if-then-else สามารถใช้ทดสอบค่าของแต่ละกรณีได้ทีละกรณี ส่วนการทำงานแบบต่อเนื่อง (fall through) สามารถทำได้โดยใช้ชุดคำสั่ง if โดยไม่ต้องมีส่วน else

ตารางควบคุม: ตรรกะของคำสั่ง switch สามารถเข้ารหัสได้ในรูปของตารางควบคุม (รูปแบบหนึ่งของตารางค้นหา ) โดยใช้ค่าของ case เป็นคีย์ และแต่ละค่าจะเข้ารหัสสิ่งที่อยู่ในส่วนของ case นั้น ๆในรูปแบบของ ตัวชี้ฟังก์ชัน ฟังก์ชัน นิรนามหรือกลไกที่คล้ายกัน

ในภาษาที่ไม่มีคำสั่ง switch เช่นLua [ ¹³^]ตารางควบคุมจะให้วิธีการในการใช้งานความหมายของคำสั่ง switch ในขณะที่เปิดใช้งานประสิทธิภาพการทำงานในขณะรันไทม์ซึ่ง if-then-else ไม่สามารถ^{ทำได้}

การจับคู่รูปแบบ: การจับคู่รูปแบบ (Pattern matching)เป็นฟังก์ชันการทำงานคล้ายสวิตช์ที่ใช้ในภาษาการเขียนโปรแกรมเชิงฟังก์ชัน หลายภาษา

ประวัติศาสตร์

ในหนังสือIntroduction to Metamathematicsที่ เขียนโดย Stephen Kleene ในปี 1952 เขา ได้พิสูจน์อย่างเป็นทางการว่าฟังก์ชันกรณี (โดยฟังก์ชัน if-then-else เป็นรูปแบบที่ง่ายที่สุด) เป็นฟังก์ชันเรียกซ้ำแบบดั้งเดิมโดยเขานิยามแนวคิด "การนิยามโดยกรณี" ในลักษณะดังต่อไปนี้:

"#F. ฟังก์ชัน φ ที่กำหนดไว้ดังนี้
φ(x , ... , x ) =
φ (x , ... , x ) ถ้า Q (x , ... , x ),
. . . . . . . . . . . .
φ (x , ... , x ) ถ้า Q (x , ... , x ),
φ (x , ... , x ) มิเช่นนั้น
โดยที่ Q , ... , Q เป็นเงื่อนไขที่ไม่ซ้ำกัน (หรือ φ(x , ... , x ) จะมีค่าตามที่กำหนดโดยข้อความแรกที่ใช้ได้) เป็นการเรียกซ้ำแบบดั้งเดิมใน φ , ..., φ , Q , ..., Q 1

— สตีเฟน คลีน^{[ 14 ]}

Kleene ได้นำเสนอการพิสูจน์เรื่องนี้โดยใช้ฟังก์ชันเรียกซ้ำแบบบูลีน "sign-of" sg( ) และ "not sign of" ~sg( ) (Kleene 1952:222-223) โดยฟังก์ชันแรกจะคืนค่า 1 หากอินพุตเป็นบวก และ −1 หากอินพุตเป็นลบ

Boolos-Burgess-Jeffrey ตั้งข้อสังเกตเพิ่มเติมว่า "การนิยามโดยกรณี" จะต้องเป็นทั้งแบบแยกออกจากกันโดยสิ้นเชิงและครอบคลุมทุกกรณีพวกเขายังเสนอการพิสูจน์ถึงการเรียกซ้ำแบบดั้งเดิมของฟังก์ชันนี้ด้วย (Boolos-Burgess-Jeffrey 2002:74-75)

รูปแบบ if-then-else เป็นพื้นฐานของรูปแบบ McCarthyโดยการใช้งานรูปแบบนี้จะเข้ามาแทนที่ทั้งการเรียกซ้ำแบบดั้งเดิมและตัวดำเนินการมิว (mu-operator )

คอมไพเลอร์ Fortranรุ่นแรกๆรองรับ คำสั่ง goto แบบคำนวณสำหรับการแตกแขนงแบบหลายทาง คอมไพเลอร์ ALGOL รุ่นแรกๆ รองรับชนิดข้อมูล SWITCH ซึ่งประกอบด้วยรายการ "นิพจน์กำหนด" คำสั่ง goto สามารถอ้างอิงตัวแปร switch และโดยการระบุดัชนี จะแตกแขนงไปยังปลายทางที่ต้องการ ด้วยประสบการณ์ที่ผ่านมา ทำให้ตระหนักว่าจำเป็นต้องมีโครงสร้างแบบหลายทางที่เป็นทางการมากขึ้น โดยมีจุดเข้าและจุดออกเพียงจุดเดียว ภาษาต่างๆ เช่นBCPL , ALGOL-WและALGOL-68ได้นำเสนอรูปแบบของโครงสร้างนี้ ซึ่งยังคงใช้กันอยู่ในภาษาโปรแกรมสมัยใหม่

ดูเพิ่มเติม

อ่านเพิ่มเติม

Stephen Kleene , 1952 (พิมพ์ซ้ำครั้งที่ 10 ปี 1991), Introduction to Metamathematics , North-Holland Publishing Company, Amsterdam NL, ISBN 0-7204-2103-9
George Boolos , John BurgessและRichard Jeffrey , 2002, ความสามารถในการคำนวณและตรรกะ: ฉบับที่สี่ , สำนักพิมพ์มหาวิทยาลัยเคมบริดจ์, เคมบริดจ์ สหราชอาณาจักร, ISBN 0-521-00758-5ปกอ่อน ดูหน้า 74–75

[ 1 ]

[ 2 ]

[ 3 ]

[ 4 ]

5 ] ใน

[ 6 ]

[ 7 ]

[ 8 ]

[

[

[

[

13

[ 14 ]