ในการเขียนโปรแกรมคอมพิวเตอร์ ตัวดำเนินการเงื่อนไขแบบไตรภาค ( ternary conditional operator)คือนิพจน์เงื่อนไขที่มีสามส่วน ได้แก่เงื่อนไขแบบบูลีน (Boolean condition ) นิพจน์thenและ นิพจน์ elseถ้าเงื่อนไขเป็นจริง นิพจน์ thenจะถูกประเมินค่า มิฉะนั้น นิพจน์ elseจะถูกประเมินค่า และส่งคืนค่า ดังนั้นจึงเป็น ตัวดำเนินการ ที่ไม่เข้มงวด (non-strict operator) เช่นเดียวกับนิพจน์เงื่อนไขอื่นๆ เรียกอีกอย่างว่าตัวดำเนินการเงื่อนไข (conditional operator ) หรือ if แบบไตรภาค (ternary if) ifแบบทันที (immediate if ) หรือ if แบบอินไลน์ (inline ifหรือiif )

แม้ว่า โดยทั่วไปแล้ว ตัวดำเนินการแบบไตรภาค (ternary operator)คือตัวดำเนินการใดๆ ที่มีอาร์กิวเมนต์สามตัว แต่ตัวดำเนินการเงื่อนไขที่มีอาร์กิวเมนต์สามตัวเป็นตัวดำเนินการที่พบได้ทั่วไปเพียงตัวเดียวในการเขียนโปรแกรม ดังนั้นจึงเรียกอย่างไม่เป็นทางการว่าตัวดำเนินการแบบไตรภาค

ภาษา Cได้นำเสนอไวยากรณ์ a ? b : cที่อ่านว่า "ถ้า a แล้ว b มิฉะนั้น c" ซึ่งใช้กันอย่างแพร่หลายในภาษาอื่นๆ ที่มีไวยากรณ์คล้าย Cบางภาษาใช้ไวยากรณ์เชิงฟังก์ชัน เช่น ในVisual Basicจะเขียนว่าIf(a, b, c).

ภาษาโปรแกรมหลายภาษารองรับนิพจน์เงื่อนไขที่มีสอง สาม หรือมากกว่าสองประโยค ภาษาที่ใช้ ไวยากรณ์คล้าย ALGOLมักจะรองรับนิพจน์เงื่อนไขด้วยไวยากรณ์เดียวกับคำสั่งเงื่อนไขif a then b else cทั่วไป

โครงสร้างนี้ปรากฏครั้งแรกในCPLในปี พ.ศ. 2506 ในรูปa → b, cแบบ^{[ 1 ] [ 2 ]}

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

ตัวดำเนินการนี้คล้ายกับวิธีการทำงานของนิพจน์เงื่อนไข (if-then-else) ในภาษาการเขียนโปรแกรมเชิงฟังก์ชัน เช่น Scheme , ML , HaskellและXQueryเนื่องจาก if-then-else สร้างเป็นนิพจน์แทนที่จะเป็นคำสั่งในภาษาเหล่านั้น

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

ตัวอย่างเช่น ในภาษา Python:

x : str = 'foo' ถ้าb เป็นจริง มิฉะนั้นจะเป็น'bar'

แทนที่จะเป็น:

x : str ถ้าb : x = 'foo' มิฉะนั้น: x = 'bar'

ในภาษาที่มีขอบเขตแบบบล็อกตัวแปรจะต้องถูกประกาศก่อนคำสั่ง if-else ตัวอย่างเช่น:

std :: string s ; if ( b ) { s = "foo" ; } else { s = "bar" ; }

การใช้ตัวดำเนินการเงื่อนไขช่วยให้สิ่งนี้ง่ายขึ้น:

std :: string s = b ? "foo" : "bar" ;

นอกจากนี้ เนื่องจากตอนนี้การกำหนดค่าเริ่มต้นเป็นส่วนหนึ่งของการประกาศ ไม่ใช่คำสั่งแยกต่างหาก ตัวระบุจึงสามารถเป็นค่าคงที่ได้ ตัวอย่างเช่น:

const std :: string s = b ? "foo" : "bar" ;

ตัวดำเนินการเงื่อนไขสามารถใช้สำหรับตัวเลือกกรณีได้ ตัวอย่างเช่น:

ยานพาหนะ= arg == 'B' ? รถบัส: arg == 'A' ? เครื่องบิน: arg == 'T' ? รถไฟ: arg == 'C' ? รถยนต์: arg == 'H' ? ม้า: เท้า;

โครงสร้างและความหมายของตัวดำเนินการจะแตกต่างกันไปตามแต่ละภาษา

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

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

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

ด้วยเหตุผลเหล่านี้ ในบางภาษา รูปแบบประโยคบอกเล่าจึงr = condition ? expr1 : expr2อาจมีความหมายแตกต่างจากรูปแบบประโยคเงื่อนไขแบบบล็อกอย่างละเอียดอ่อน if(condition){r=expr1;}else{r=expr2;}

ในเกือบทุกภาษา ตัวดำเนินการไตรภาคเป็นแบบเชื่อมโยงทางขวาดังนั้นจึงa == 1 ? "one" : a == 2 ? "two" : "many"ประเมินค่าได้อย่างเป็นธรรมชาติเป็นa == 1 ? "one" : (a == 2 ? "two" : "many")ซึ่งหมายความว่าสามารถเชื่อมโยงกันได้คล้ายกับif ... else if ... else if ... elseโซ่ ข้อยกเว้นหลักคือPHPซึ่งก่อนเวอร์ชัน 8 เป็นแบบเชื่อมโยงทางซ้าย (เช่น นิพจน์เดียวกันจะประเมินค่าเป็น(a == 1 ? "one" : a == 2) ? "two" : "many"ซึ่งไม่ค่อยเป็นสิ่งที่โปรแกรมเมอร์คาดหวัง) ^{[ 3 ]}และหลังจากนั้นจะไม่เชื่อมโยงกัน^{[ 4 ]}

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

Adaเวอร์ชัน 2012 ได้แนะนำนิพจน์เงื่อนไข (โดยใช้ifand case) ซึ่งเป็นส่วนหนึ่งของชุดนิพจน์ที่ขยายใหญ่ขึ้น รวมถึงนิพจน์เชิงปริมาณและฟังก์ชันนิพจน์ เหตุผลสำหรับ Ada 2012 ^{[ 5 ]}ระบุถึงแรงจูงใจที่ Ada ไม่เคยมีมาก่อน รวมถึงแรงจูงใจในการเพิ่มเข้ามาในครั้งนี้ เช่น เพื่อรองรับ "สัญญา" (ซึ่งเป็นสิ่งใหม่เช่นกัน)

ค่าจ้างต่อชั่วโมง:= ( ถ้าวันเป็นวันอาทิตย์ให้12.50 มิฉะนั้น10.00 );

เมื่อค่าของif_expressionเป็นประเภท Boolean เองelseส่วนนั้นอาจถูกละเว้นได้ โดยค่าจะเป็น True สามารถเชื่อมโยงเงื่อนไขหลายเงื่อนไขเข้าด้วยกันได้โดยใช้elsif.

ALGOL 60 ได้นำเสนอการใช้เงื่อนไข (เงื่อนไขแบบสามทาง) ในภาษา การเขียนโปรแกรมเชิงคำสั่ง

ประโยคเงื่อนไขนี้:

integer opening_time ; if day = Sunday then opening_time := 12 ; else opening_time := 9 ;

สามารถเขียนใหม่ได้โดยใช้ตัวดำเนินการเงื่อนไข:

เวลาเปิดทำการเป็นจำนวนเต็ม; เวลาเปิดทำการ:= ถ้าวันนั้นเป็นวันอาทิตย์ให้กำหนดเป็น12 มิฉะนั้นให้เป็น 9 ;

เงื่อนไขการเลือก (เงื่อนไข if และเงื่อนไข case) ทั้งสอง ข้อ ของALGOL 68 สนับสนุนสิ่งต่อไปนี้:

เงื่อนไขตัวเลือกเดียว

if condition then statements [ else statements ] fiหรือแบบย่อ:( condition | statements | statements )

เงื่อนไขตัวเลือกแบบลูกโซ่

if condition1 then statements elif condition2 then statements [ else statements ] fiหรือรูปแบบย่อ: ( condition1 | statements |: condition2 | statements | statements ).

ตัวดำเนินการไตรภาคที่แท้จริงมีอยู่สำหรับนิพจน์ทางคณิตศาสตร์:

(( ผลลัพธ์=เงื่อนไข? ค่าถ้าเป็นจริง: ค่าถ้าเป็นเท็จ))

สำหรับสตริงนั้นมีวิธีแก้ไขอยู่ เช่น:

ผลลัพธ์= $(ถ้าเงื่อนไขเป็นจริงให้แสดง ค่า " ถ้าเป็นจริง" มิฉะนั้นให้แสดงค่า " ถ้า เป็น เท็จ")

คำสั่ง bash ใดconditionๆ ก็สามารถใช้ได้ หากการทำงานเสร็จสิ้นอย่างสำเร็จ คำสั่ง echo ตัวแรกจะถูกเรียกใช้งาน มิฉะนั้น คำสั่ง echo ตัวที่สองจะถูกเรียกใช้งาน

โค้ดต่อไปนี้ในภาษาCจะกำหนดresultค่าให้กับตัวแปร `true` xถ้าเงื่อนไขเป็น a > bจริง และกำหนดค่าให้กับตัวแปร ` yfalse` ในกรณีอื่น ๆ นี่คือไวยากรณ์เดียวกันกับในภาษาที่เกี่ยวข้องหลายภาษา เช่นC++ , Java , JavaScriptและDart

ผลลัพธ์= a > b ? x : y ;

เฉพาะนิพจน์ที่เลือกเท่านั้นที่จะได้รับการประเมิน ในตัวอย่างนี้xและyไม่จำเป็นต้องมีการประเมิน แต่นิพจน์เหล่านี้สามารถมีผลข้างเคียงได้ เฉพาะผลข้างเคียงสำหรับค่านิพจน์ที่เลือกเท่านั้นที่จะเกิดขึ้น^{[ 6 ] [ 7 ]}

ถ้าxและyมีชนิดข้อมูลเดียวกัน โดยทั่วไปแล้วนิพจน์เงื่อนไขจะมีชนิดข้อมูลนั้น มิฉะนั้น กฎที่ควบคุมชนิดข้อมูลที่ได้จะแตกต่างกันเล็กน้อยในแต่ละภาษา:

• ใน C++ การแปลงประเภททางคณิตศาสตร์ตามปกติจะดำเนินการเพื่อแปลงxและyเป็นประเภททั่วไป หากทั้งสองเป็นประเภทตัวชี้หรือการอ้างอิง หรือตัวหนึ่งเป็นประเภทตัวชี้และอีกตัวหนึ่งเป็นนิพจน์คงที่ที่ประเมินค่าเป็น 0 การแปลงตัวชี้หรือการอ้างอิงจะดำเนินการเพื่อแปลงเป็นประเภททั่วไป^{[ 8 ]}
• ใน C# หากนิพจน์หนึ่งสามารถแปลงเป็นประเภทของนิพจน์อื่นได้โดยปริยาย จะใช้ประเภทนั้น มิฉะนั้นจะเกิดข้อผิดพลาดขณะคอมไพล์^{[ 9 ]}
• ในภาษาที่มีการกำหนดประเภทแบบไดนามิก นิพจน์ที่ถูกประเมินจะมีประเภทเดียวกับนิพจน์ที่ถูกเลือก

นอกจากนี้ ใน C++ นิพจน์เงื่อนไขสามารถใช้เป็นlvalue ได้หากทั้งxและyเป็น lvalue แม้ว่าในทางปฏิบัติจะไม่ค่อยได้ใช้ก็ตาม^{[ 10 ]}

( foo ? bar : baz ) = frink ;

การกำหนดค่าโดยใช้เงื่อนไขในภาษาCommon Lisp :

( setq ผลลัพธ์( ถ้า( > a b ) x y ))

รูปแบบอื่น:

( ถ้า( > a b ) ( ตั้งค่าผลลัพธ์x ) ( ตั้งค่าผลลัพธ์y ))

ในdBaseฟังก์ชันเงื่อนไขนี้iif(<expL>, <expT>, <expF>)เรียกว่า "Immediate IF" ซึ่งใช้การประเมินแบบย่อ (โดยจะประเมินเพียงหนึ่งใน<expT>หรือ<expF> เท่านั้น )

ตัวอย่างเช่น หากต้องการเรียงลำดับรายการตามชื่อถนนและ (ในกรณีส่วนใหญ่) หมายเลขบ้าน สามารถพิมพ์ได้ดังนี้

index on iif(instr(addr," ") , substr(addr,instr(addr," ")+1,10) + left(addr,instr(addr," ")-1) , addr)ไปยังไฟล์ดัชนี 

ที่พรอมต์คำสั่ง dBASE III จากนั้นคัดลอกหรือส่งออกตาราง

ในฐานะส่วนหนึ่งของมาตรฐาน Fortran-90 ตัวดำเนินการแบบไตรภาค (ternary operator) ได้ถูกเพิ่มเข้ามาในFortranในฐานะฟังก์ชันพื้นฐาน (intrinsic function merge) :

ตัวแปร= ผสาน( x , y , a > b )

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

Fortran-2023 ได้เพิ่มนิพจน์แบบมีเงื่อนไข ซึ่งจะประเมินนิพจน์ใดนิพจน์หนึ่งโดยขึ้นอยู่กับนิพจน์แบบมีเงื่อนไขนั้น:

ตัวแปร= ( a > b ? x : y )

Kotlin ไม่ได้รวมตัว?:ดำเนินการแบบไตรภาคแบบดั้งเดิมไว้ด้วย อย่างไรก็ตามifสามารถใช้เป็นนิพจน์ที่สามารถกำหนดค่าได้^{[ 11 ]}ซึ่งให้ผลลัพธ์เดียวกัน

val max = ถ้า( a > b ) a มิฉะนั้นb

ภาษา Lua ไม่มีตัวดำเนินการเงื่อนไขแบบดั้งเดิม อย่างไรก็ตาม พฤติกรรมการลัดวงจรของ ตัวดำเนินการ and`and` orช่วยให้สามารถจำลองพฤติกรรมนี้ได้ ดังต่อไปนี้เทียบเท่ากับ: var = cond ? a : b`.`

var = cond และa หรือb

การดำเนินการนี้จะสำเร็จ เว้นแต่ว่าaเงื่อนไขดังกล่าวจะเป็นเท็จทางตรรกะ ในกรณีนี้ นิพจน์จะให้ผลลัพธ์เป็นเท็จเสมอbซึ่งอาจส่งผลให้เกิดพฤติกรรมที่ไม่คาดคิดได้หากละเลยเงื่อนไขนี้

นอกจากนี้ยังมีรูปแบบอื่นๆ ที่สามารถใช้ได้ แต่โดยทั่วไปแล้วจะมีรายละเอียดมากกว่า:

var = ( { [ true ] = a , [ false ] = b } )[ not not cond ]

Luau ซึ่งเป็นภาษาถิ่นของ Lua มีนิพจน์แบบไตรภาคที่มีลักษณะคล้ายกับคำสั่ง if แต่ต่างจากคำสั่ง if ตรงที่ไม่มีendคำหลัก และelseจำเป็นต้องมีเงื่อนไข สามารถเพิ่มelseifเงื่อนไขได้ตามต้องการ ออกแบบมาเพื่อแทนที่สำนวนเดิมและคาดว่าจะทำงานได้อย่างถูกต้องในทุกกรณี^{[ 12 ]}condandaorb

-- ใน Luau var = if cond then a else b-- พร้อมเงื่อนไข elseif เครื่องหมาย= ถ้าvar < 0 แล้ว-1 ถ้าvar == 0 แล้ว0 มิฉะนั้น1

ภาษา Pascal เป็นทั้งการทำให้ง่ายขึ้นและการต่อยอดจาก ALGOL 60 แต่ได้ตัดการแสดงนิพจน์แบบมีเงื่อนไขออกไป

RemObjects Oxygeneได้เพิ่มตัวดำเนินการแบบไตรภาคให้กับ Object Pascal ในราวปี 2011 ^{[ 13 ]}และในปี 2025 Delphi ก็ได้ทำตามเช่นกัน^{[ 14 ]} Oxygene รองรับคำสั่ง case/switchซึ่งโดยพื้นฐานแล้วคือ if ที่ทำซ้ำๆ ในรูปแบบนิพจน์ที่ประเมินค่าได้เช่นกัน^{[ 15 ]}

Pythonมีนิพจน์เงื่อนไขแบบไตรภาคตั้งแต่เวอร์ชัน 2.5 (กันยายน 2549) ^{[ 16 ]}ตัวดำเนินการเงื่อนไขของ Python แตกต่างจากตัวดำเนินการแบบ C ?:ในลำดับของตัวถูกดำเนินการ รูปแบบทั่วไปคือ: ^{[ 17 ]}

ผลลัพธ์= x ถ้าa > b มิฉะนั้นy

รูปแบบนี้ชวนให้พิจารณาxทั้งค่าปกติและyกรณีพิเศษ แตกต่างจากคำสั่งเงื่อนไขใน Python ตรงที่elifไม่รองรับการใช้ clause แต่สามารถใช้เงื่อนไขแบบซ้อนกันได้

เนื่องจาก Rust เป็น ภาษาการเขียนโปรแกรมเชิงนิพจน์เงื่อนไขทั้งหมดจึงเป็นนิพจน์ ไม่ใช่คำสั่ง ดังนั้นไวยากรณ์จึงทำงานเหมือนตัวดำเนินการไตรภาคแบบ C เวอร์ชันก่อนหน้าของภาษามีตัวดำเนินการ แต่ถูกลบออก^{[ 18 ]}เนื่องจากซ้ำซ้อนกับ. ^{[ 19 ]}if expr1 else expr2?:?:if

โปรดสังเกตว่าโค้ดด้านล่างไม่มีเครื่องหมายเซมิโคลอน เมื่อเทียบกับบล็อกคำสั่งแบบบังคับif... elseและมีเครื่องหมายเซมิโคลอนอยู่ที่ท้ายการกำหนดค่าให้กับy.

ให้x = 5 ;ให้y = ถ้าx == 5 { 10 } มิเช่นนั้น{ 15 };

สามารถเขียนได้อีกแบบว่า:

ให้y = ถ้าx == 5 { 10 } มิเช่นนั้น{ 15 };

วงเล็บปีกกาเป็นสิ่งที่จำเป็นในนิพจน์เงื่อนไขของ Rust

คุณสามารถใช้matchสำนวนนี้ได้เช่นกัน:

let y = match x { 5 => 10 , _ => 15 , };

ทุกการแสดงออก (การส่งข้อความ) มีค่า ดังนั้นจึงifTrue:ifFalse:สามารถนำไปใช้ได้ดังนี้:

|x y|x := 5. y := ( x == 5 ) ifTrue: [ 10 ] ifFalse: [ 15 ] .

นิพจน์ SQL นี้CASEเป็นการขยายแนวคิดของตัวดำเนินการแบบไตรภาค (ternary operator) โดยแทนที่จะระบุเงื่อนไขหนึ่งข้อและผลลัพธ์สองข้อสามารถระบุเงื่อนไขได้ nข้อ และ ผลลัพธ์ n+1 ข้อ

หากมีเงื่อนไขเพียงข้อเดียว จะเทียบเท่ากับตัวดำเนินการแบบไตรภาค (แม้ว่าจะใช้คำยุ่งยากกว่าก็ตาม):

เลือก( กรณีเมื่อa > b แล้วx มิฉะนั้นy สิ้นสุด) เป็นเงื่อนไขตัวอย่างจากแท็บ;

สามารถขยายแนวคิดนี้ไปสู่เงื่อนไขหลายข้อได้:

เลือก( กรณีเมื่อa > b แล้วx เมื่อa < b แล้วy มิฉะนั้นz สิ้นสุด) เป็นเงื่อนไขตัวอย่างจากตาราง tab ;

Visual Basicมีฟังก์ชันเงื่อนไขแบบสามทาง (ternary conditional function) IIfดังแสดงในโค้ดต่อไปนี้:

Dim opening_time As Integer = IIf (( day = SUNDAY ), 12 , 9 )

ในฐานะฟังก์ชัน ค่าของอาร์กิวเมนต์ทั้งสามจะถูกประเมินก่อนที่จะเรียกใช้ฟังก์ชัน เพื่อหลีกเลี่ยงการประเมินนิพจน์ที่ไม่ถูกเลือก จึงIfมีการเพิ่มคำหลัก (ใน Visual Basic .Net 9.0) ในฐานะตัวดำเนินการเงื่อนไขแบบไตรภาคที่แท้จริง ซึ่งทำให้โค้ดต่อไปนี้หลีกเลี่ยงข้อยกเว้นได้หากนำไปใช้โดยใช้IIfแทน:

Dim name As String = If ( person Is Nothing , "" , person . Name )

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

• คำอธิบายการใช้งานตัวดำเนินการ IF ในภาษา Visual Basic
• คำอธิบายเกี่ยวกับนิพจน์เงื่อนไขในภาษา Python (PEP 308)
• คำอธิบายในข้อกำหนดภาษาจาวา
• คำอธิบายในเอกสารประกอบภาษา PHP