ที่ประกอบไปด้วยหรือไม่ที่จะไม่ประกอบไปด้วย? [ปิด]

ฉันเป็นผู้ให้การสนับสนุนผู้ประกอบการที่ประกอบไปด้วยส่วนตัว: ()? :; ฉันรู้ว่ามันมีที่อยู่ แต่ฉันได้เจอโปรแกรมเมอร์หลายคนที่ไม่เคยใช้งานมาก่อนและบางคนก็ใช้มันบ่อยเกินไป

คุณรู้สึกยังไงกับเรื่องนี้? คุณเห็นโค้ดที่น่าสนใจอะไรที่ใช้มัน?

ใช้สำหรับการแสดงออกอย่างง่ายเท่านั้น :

int a = (b > 10) ? c : d;

อย่าโยงหรือทำเครื่องหมายผู้ประกอบการที่สามเนื่องจากยากต่อการอ่านและสับสน:

int a = b > 10 ? c < 20 ? 50 : 80 : e == 2 ? 4 : 8;

ยิ่งไปกว่านั้นเมื่อใช้ตัวดำเนินการแบบไตรภาคพิจารณาการจัดรูปแบบรหัสในวิธีที่ปรับปรุงความสามารถในการอ่าน:

int a = (b > 10) ? some_value                 
                 : another_value;

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

ฉันรักพวกเขาโดยเฉพาะอย่างยิ่งในภาษาที่ปลอดภัยประเภท

ฉันไม่เห็นสิ่งนี้:

int count = (condition) ? 1 : 0;

ยากกว่านี้ไหม:

int count;

if (condition)
{
  count = 1;
} 
else
{
  count = 0;
}

แก้ไข -

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

ถูกล่ามโซ่ฉันสบายดีด้วย - ซ้อนกันไม่มาก

ฉันมักจะใช้พวกเขามากขึ้นใน C เพียงแค่ b / c พวกเขาเป็นคำสั่ง if ที่มีค่าดังนั้นจึงลดการทำซ้ำหรือตัวแปรที่ไม่จำเป็น:

x = (y < 100) ? "dog" :
    (y < 150) ? "cat" :
    (y < 300) ? "bar" : "baz";

ค่อนข้างมากกว่า

     if (y < 100) { x = "dog"; } 
else if (y < 150) { x = "cat"; }
else if (y < 300) { x = "bar"; } 
else              { x = "baz"; }

ในการมอบหมายเช่นนี้ฉันพบว่ามันน้อยไปกว่า refactor และชัดเจนขึ้น

เมื่อฉันทำงานในทับทิมในอีกฉันมีแนวโน้มที่จะใช้if...else...endเพราะมันแสดงออกเช่นกัน

x =   if (y < 100) then "dog"
    elif (y < 150) then "cat"
    elif (y < 300) then "bar"
    else                "baz"
    end

(แม้ว่าเป็นที่ยอมรับสำหรับบางสิ่งบางอย่างที่เรียบง่ายแบบนี้ฉันอาจใช้ผู้ประกอบการที่สามแล้ว)

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

แต่มีสถานการณ์มากมายที่การใช้งานตัว?:ดำเนินการอย่างระมัดระวังอาจส่งผลให้เกิดโค้ดที่อ่านง่ายกว่าจริง ๆ ตัวอย่างเช่น:

int compareTo(Object object) {
    if((isLessThan(object) && reverseOrder) || (isGreaterThan(object) && !reverseOrder)) {
       return 1;
    if((isLessThan(object) && !reverseOrder) || (isGreaterThan(object) && reverseOrder)) {
       return -1;
    else
      return 0;              
}

เปรียบเทียบกับสิ่งนี้:

int compareTo(Object object) {
    if(isLessThan(object))
        return reverseOrder ? 1 : -1;         
    else(isGreaterThan(object))
        return reverseOrder ? -1 : 1;
    else        
       return 0;              
}

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

มันเป็นคำถามของสไตล์จริงๆ กฎของจิตใต้สำนึกที่ฉันมักจะปฏิบัติตามคือ:

• ประเมินเพียง 1 นิพจน์เท่านั้นดังนั้นfoo = (bar > baz) ? true : falseไม่ใช่foo = (bar > baz && lotto && someArray.Contains(someValue)) ? true : false
• ถ้าฉันใช้มันสำหรับตรรกะการแสดงผลเช่น <%= (foo) ? "Yes" : "No" %>
• ใช้เพื่อการมอบหมายเท่านั้นจริงๆ; ไม่เคยไหลตรรกะ (ดังนั้นไม่เคย(foo) ? FooIsTrue(foo) : FooIsALie(foo)) ตรรกะการไหลในยุคที่สามเป็นเรื่องโกหกไม่สนใจจุดสุดท้าย

ฉันชอบเพราะมันกระชับและสง่างามสำหรับการดำเนินการมอบหมายอย่างง่าย

เช่นเดียวกับคำถามความคิดเห็นมากมายคำตอบก็คือ: ขึ้นอยู่กับมัน

สำหรับสิ่งที่ชอบ:

return x ? "Yes" : "No";

ฉันคิดว่ามันมากรัดกุมมากขึ้น (และเร็วสำหรับฉันที่จะแยกกว่า):

if (x) {
    return "Yes";
} else {
    return "No";
}

ทีนี้ถ้าการแสดงออกตามเงื่อนไขของคุณซับซ้อนการดำเนินการแบบไตรภาคไม่ใช่ทางเลือกที่ดี สิ่งที่ต้องการ:

x && y && z >= 10 && s.Length == 0 || !foo

ไม่ใช่ตัวเลือกที่ดีสำหรับผู้ประกอบการที่ประกอบไปด้วยคน

นอกจากนี้หากคุณเป็นโปรแกรมเมอร์ C GCC มีส่วนขยายที่อนุญาตให้คุณยกเว้นส่วนที่ประกอบไปด้วยสามส่วนที่เป็นจริงเช่นนี้:

/* 'y' is a char * */
const char *x = y ? : "Not set";

ซึ่งจะตั้งค่าxการyสมมติไม่ได้y NULLสิ่งที่ดี.

ในความคิดของฉันมันเหมาะสมที่จะใช้ผู้ประกอบการที่สามในกรณีที่จำเป็นต้องมีการแสดงออก

ในกรณีอื่น ๆ ดูเหมือนว่าผู้ประกอบการที่ประกอบไปด้วยลดความชัดเจน

โดยการวัดความซับซ้อนของวัฏจักรการใช้ifข้อความหรือผู้ประกอบการที่ประกอบไปด้วยกันนั้นเทียบเท่ากัน ดังนั้นโดยการวัดนั้นคำตอบคือไม่ความซับซ้อนจะเหมือนกันทุกประการ

โดยมาตรการอื่น ๆ เช่นความสามารถในการอ่านความสามารถในการบำรุงรักษาและ DRY (Don't-Repeat-Yourself) ตัวเลือกทั้งสองอาจพิสูจน์ได้ดีกว่าวิธีอื่น

ฉันใช้บ่อยในสถานที่ที่ฉันถูก จำกัด ให้ทำงานในนวกรรมิก - ตัวอย่างเช่น. NET 3.5 LINQ to XML constructs ใหม่ - เพื่อกำหนดค่าเริ่มต้นเมื่อพารามิเตอร์ทางเลือกเป็นโมฆะ

ตัวอย่างที่คาดหวัง:

var e = new XElement("Something",
    param == null ? new XElement("Value", "Default")
                  : new XElement("Value", param.ToString())
);

หรือ (ขอบคุณดาวเคราะห์น้อย)

var e = new XElement("Something",
    new XElement("Value",
        param == null ? "Default"
                      : param.ToString()
    )
);

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

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

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

ฉันเห็นด้วยกับ jmulder: มันไม่ควรใช้แทน a if, แต่มันมีที่สำหรับใช้ในการแสดงออกทางกลับหรือภายในนิพจน์:

echo "Result: " + n + " meter" + (n != 1 ? "s" : "");
return a == null ? "null" : a;

อดีตเป็นเพียงตัวอย่างเท่านั้นควรใช้การสนับสนุนพหูพจน์ i18n ที่ดีกว่า!

(แฮ็คของวัน)

#define IF(x) x ?
#define ELSE :

จากนั้นคุณสามารถทำ if-then-else เป็นนิพจน์:

int b = IF(condition1)    res1
        ELSE IF(condition2)  res2
        ELSE IF(conditions3) res3
        ELSE res4;

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

ฉันคิดว่าผู้ประกอบการที่ควรจะใช้เมื่อจำเป็น เห็นได้ชัดว่าเป็นตัวเลือกที่เป็นอัตนัย แต่ฉันพบว่าการแสดงออกอย่างง่าย ๆ (โดยเฉพาะการแสดงออกทางกลับ) นั้นชัดเจนกว่าการทดสอบเต็มรูปแบบ ตัวอย่างใน C / C ++:

return (a>0)?a:0;

เปรียบเทียบกับ:

if(a>0) return a;
else return 0;

คุณมีกรณีที่โซลูชันอยู่ระหว่างผู้ประกอบการที่ประกอบไปด้วยสามและการสร้างฟังก์ชั่น ตัวอย่างเช่นใน Python:

l = [ i if i > 0 else 0 for i in lst ]

ทางเลือกคือ:

def cap(value):
    if value > 0:
        return value
    return 0
l = [ cap(i) for i in lst ]

มีความจำเป็นพอที่ใน Python (เป็นตัวอย่าง) สำนวนดังกล่าวสามารถเห็นได้เป็นประจำ:

l = [ ((i>0 and [i]) or [0])[0] for i in lst ]

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

ฉันชอบ 'em ฉันไม่รู้ว่าทำไม แต่ฉันรู้สึกเท่ห์มากเมื่อฉันใช้สำนวนที่ประกอบไปด้วยสาม

ฉันเคยเห็นสัตว์ร้ายเช่นนี้ (จริง ๆ แล้วมันแย่กว่าเดิมเพราะมันเป็น ValidateDate และตรวจสอบเดือนและวันเช่นกัน แต่ฉันไม่สามารถใส่ใจที่จะจดจำสิ่งทั้งหมดได้):

isLeapYear =
    ((yyyy % 400) == 0)
    ? 1
    : ((yyyy % 100) == 0)
        ? 0
        : ((yyyy % 4) == 0)
            ? 1
            : 0;

โดยที่ชัดถ้อยชัดคำชุดของ if-statement จะดีกว่า (แม้ว่าอันนี้ยังคงดีกว่ารุ่นแมโครที่ฉันเคยเห็น)

ฉันไม่รังเกียจสำหรับสิ่งเล็ก ๆ เช่น:

reportedAge = (isFemale && (Age >= 21)) ? 21 + (Age - 21) / 3 : Age;

หรือแม้แต่เรื่องยุ่งยากเล็กน้อยเช่น:

printf ("Deleted %d file%s\n", n, (n == 1) ? "" : "s");

ไวยากรณ์ของมันแย่มาก ฉันพบว่าฟังก์ชัน ifs มีประโยชน์มากและมักทำให้โค้ดอ่านง่ายขึ้น

ฉันขอแนะนำให้สร้างมาโครเพื่อให้อ่านได้ง่ายขึ้น แต่ฉันแน่ใจว่ามีบางคนที่สามารถสร้างเคสที่น่ากลัวได้ (เนื่องจาก CPP อยู่เสมอ)

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

int result = do_something();
if( result != 0 )
{
  debug_printf("Error while doing something, code %x (%s)\n", result,
                result == 7 ? "ERROR_YES" :
                result == 8 ? "ERROR_NO" :
                result == 9 ? "ERROR_FILE_NOT_FOUND" :
                "Unknown");
}

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

ฉันชอบที่จะหลีกเลี่ยงการใช้คำฟุ่มเฟื่อย แต่เมื่อมันทำให้รหัสง่ายขึ้นมากที่จะรับฉันจะไปสำหรับ verbosity

พิจารณา:

String name = firstName;

if (middleName != null) {
    name += " " + middleName;
}

name += " " + lastName;

ตอนนี้มันค่อนข้างละเอียด แต่ฉันคิดว่ามันอ่านง่ายกว่า:

String name = firstName + (middleName == null ? "" : " " + middleName)
    + " " + lastName;

หรือ:

String name = firstName;
name += (middleName == null ? "" : " " + middleName);
name += " " + lastName;

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

เมื่อ:

$ var = (ง่าย ๆ > ทดสอบ? simple_result_1: simple_result_2);

จูบ.

ฉันมักจะใช้ในสิ่งต่าง ๆ เช่นนี้:

before:

if(isheader)
    drawtext(x,y,WHITE,string);
else
    drawtext(x,y,BLUE,string);

after:

    drawtext(x,y,isheader==true?WHITE:BLUE,string);

เป็นคนอื่นได้ชี้ให้เห็นพวกเขาจะดีสำหรับเงื่อนไขง่าย ๆ ฉันชอบพวกเขาเป็นค่าเริ่มต้น (เช่น| |และหรือการใช้งานใน javascript และ python) เช่น

int repCount = pRepCountIn ? *pRepCountIn : defaultRepCount;

การใช้งานทั่วไปอื่นคือการเริ่มต้นการอ้างอิงใน C ++ เนื่องจากการอ้างอิงจะต้องมีการประกาศและเริ่มต้นในคำสั่งเดียวกันคุณไม่สามารถใช้คำสั่ง if

SomeType& ref = pInput ? *pInput : somethingElse;

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

ฉันเพิ่งเห็นการเปลี่ยนแปลงในผู้ประกอบการที่สาม (ดีเรียงลำดับ) ที่ทำให้มาตรฐาน "()?:" ตัวแปรดูเหมือนจะเป็นพารากอนของความชัดเจน:

var Result = [CaseIfFalse, CaseIfTrue][(boolean expression)]

หรือเพื่อยกตัวอย่างที่เป็นรูปธรรมมากขึ้น:

var Name = ['Jane', 'John'][Gender == 'm'];

โปรดทราบว่านี่คือ Javascript ดังนั้นสิ่งต่าง ๆ ที่อาจเป็นไปไม่ได้ในภาษาอื่น (ขอบคุณ)

สำหรับกรณีง่าย ๆ ฉันชอบที่จะใช้มัน ที่จริงแล้วมันง่ายต่อการอ่าน / รหัสเช่นพารามิเตอร์สำหรับฟังก์ชั่นหรือสิ่งต่าง ๆ เช่นนั้น นอกจากนี้เพื่อหลีกเลี่ยงการขึ้นบรรทัดใหม่ฉันชอบที่จะรักษาด้วยถ้าทั้งหมดของฉัน / อื่น

Neseting มันจะเป็นสิ่งที่ไม่ควรทำในหนังสือของฉัน

ดังนั้นการกลับมาทำงานอีกครั้งถ้า / อื่นฉันจะใช้ผู้ประกอบการที่ประกอบไปด้วย สำหรับกรณีอื่น ๆ ถ้าปกติ / อื่นถ้า / อื่น ๆ (หรือเปลี่ยน)

ฉันชอบกรณีพิเศษของ Groovy ของผู้ประกอบการที่เรียกว่าผู้ประกอบการที่เรียกว่า Elvis:?:

expr ?: default

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

สำหรับงานง่าย ๆ เช่นการกำหนดค่าที่แตกต่างขึ้นอยู่กับเงื่อนไขว่ายอดเยี่ยม ฉันจะไม่ใช้มันเมื่อมีการแสดงออกที่ยาวขึ้นทั้งนี้ขึ้นอยู่กับเงื่อนไขของสรรพสิ่ง

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

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

x[if y > 5 then 5 else y] := "Y" 

... ซึ่งฉันพบว่าสามารถอ่านได้มากกว่าตัวดำเนินการเปรียบเทียบ ternery :-)

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

ซึ่งหมายความว่าหากคุณสามารถทำเช่นนั้นใน C (หรือภาษาอื่นใดที่มีผู้ดำเนินการ ternery) คุณจะไม่จำเป็นต้องมีผู้ดำเนินการ ternery เลย

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

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