ฉันเกลียดการอ้างอิงเนื้อหาที่ชำระเงินแล้ว แต่วิดีโอนี้แสดงสิ่งที่ฉันกำลังพูดถึง 12 นาทีอย่างแม่นยำใน Robert Martin ดูที่นี่:

และกล่าวว่า "หนึ่งในสิ่งที่ฉันชอบทำคือกำจัดวงเล็บปีกกาที่ไร้ประโยชน์" เมื่อเขาเปลี่ยนมันเป็นสิ่งนี้:

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

เพื่อความเป็นธรรมกับลุงบ๊อบเขาได้ทำการปรับเปลี่ยนวิธีการจาวาแบบยาวลงไปสู่ฟังก์ชั่นเล็ก ๆ น้อย ๆ ที่ผมเห็นว่าสามารถอ่านได้ง่ายขึ้น เมื่อเขาเปลี่ยนมันเสร็จ (22.18) ดูเหมือนว่า:

ฉันสงสัยว่าควรจะตรวจสอบการลบวงเล็บหรือไม่ ฉันคุ้นเคยกับแนวทางปฏิบัติที่ดีที่สุดแล้ว ลุงบ๊อบจะถูกท้าทายในประเด็นนี้หรือไม่? ลุงบ๊อบปกป้องความคิดนี้หรือไม่?

การอ่านไม่ใช่เรื่องเล็ก

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

ฉันไม่เคยท้าทายใครที่นับถือศาสนาเกี่ยวกับการใช้เครื่องมือจัดฟันหลังจากความล้มเหลวเล็กน้อยนั้น

ดังนั้นฉันจึงเห็นประโยชน์ของการอ่าน แต่ฉันก็ตระหนักถึงปัญหาที่อาจเกิดขึ้นเมื่อคุณละทิ้งการจัดฟันออก

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

คุณสามารถค้นหาโปรโมชั่นที่เผยแพร่หรือการปฏิเสธสไตล์ที่ไม่มีการรั้งได้ที่นี่หรือที่นี่หรือที่ใดก็ตามที่เพิงจักรยานถูกทาสี

ก้าวออกจากจักรยานหายจำความผิดพลาด OS X / iOS SSL ที่ยอดเยี่ยมของปี 2014 ได้หรือไม่

if ((err = SSLHashSHA1.update(&hashCtx, &serverRandom)) != 0)
    goto fail;
if ((err = SSLHashSHA1.update(&hashCtx, &signedParams)) != 0)
    goto fail;
    goto fail;
if ((err = SSLHashSHA1.final(&hashCtx, &hashOut)) != 0)
    goto fail;

ใช่ "เกิด" โดยไม่มีการปิดกั้นบล็อกhttps://www.imperialviolet.org/2014/02/22/applebug.html

การตั้งค่าอาจขึ้นอยู่กับสไตล์รั้ง ถ้าฉันต้องเขียน

if (suiteSetup)
{
    includePage(mode, suiteSetup);
}

ฉันอาจจะกินพื้นที่มากเกินไป แต่

if (suiteSetup) {
    includePage(mode, suiteSetup);
}

ใช้เพียงหนึ่งบรรทัด "พิเศษ"

ฉันรู้ว่าคุณไม่ได้ถาม แต่ถ้าฉันทำงานคนเดียวฉันเป็นคนนอกรีต หากฉันลบเครื่องมือจัดฟันฉันต้องการ

if (suiteSetup != null) includePage(mode, suiteSetup);

มันไม่มีปัญหาด้านภาพเช่นเดียวกับบั๊กสไตล์ SSL ของ iOS แต่จะบันทึกบรรทัดที่ "ไม่จำเป็น" ได้มากกว่าที่ลุงบ็อบทำ;) อ่านได้ดีถ้าคุณคุ้นเคยกับมันและมีการใช้งานหลักใน Ruby ( includePage(mode, suiteSetup) unless suiteSetup.nil?) อืมเพิ่งรู้ว่ามีความคิดเห็นมากมาย

ลุงบ๊อบมีการป้องกันหลายชั้นต่อความผิดพลาดที่ไม่ธรรมดาเมื่อ "การจัดฟันอยู่เสมอ" เป็นภูมิปัญญาที่แพร่หลาย:

1. การตั้งค่าส่วนบุคคลที่แข็งแกร่งสำหรับเงื่อนไขแบบบรรทัดเดียวดังนั้นแบบหลายบรรทัดจึงโดดเด่นและได้รับการตรวจสอบอย่างละเอียด
2. ตัวแก้ไขที่จะทำให้เกินโดยอัตโนมัติเมื่อคุณแทรกบรรทัดที่สอง
3. ชุดทดสอบหน่วยที่สมบูรณ์ที่เขาทำงานอย่างต่อเนื่อง
4. ชุดการทดสอบการรวมที่สมบูรณ์
5. การตรวจสอบโดยเพื่อนทำก่อนที่จะรวมรหัสของเขา
6. รันการทดสอบทั้งหมดอีกครั้งโดยเซิร์ฟเวอร์การรวมอย่างต่อเนื่อง
7. ทดสอบโดยแผนกคุณภาพผลิตภัณฑ์

ฉันคิดว่าถ้ามีคนตีพิมพ์ความท้าทายให้กับลุงบ๊อบเขาคงจะมีข้อโต้แย้งที่ดีในประเด็นข้างต้น นี่เป็นหนึ่งในข้อผิดพลาดที่ง่ายที่สุดในการจับ แต่เนิ่น ๆ

ส่วนใหญ่เป็นความชอบส่วนตัวอย่างไรก็ตามมีบางสิ่งที่ต้องพิจารณา

ข้อบกพร่องที่เป็นไปได้

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

รหัสที่ถูกต้อง (ที่อ่านเช่นนี้อาจเป็นข้อบกพร่อง)

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

เราเริ่มต้นด้วย:

if (foo)
    bar();

นักพัฒนาเพิ่มความคิดเห็นที่เป็นประโยชน์

if (foo)
    // At this point we know foo is valid.
    bar();

ต่อมาเมื่อนักพัฒนาขยายตัว

if (foo)
    // At this point we know foo is valid.
    // This never fails but is too slow even for debug, so keep disabled.
    // assert(is_valid(foo));
    bar();

หรือเพิ่มบล็อกซ้อนกัน:

if (foo)
    while (i--) {
        bar(i);
        baz(i);
    }

หรือใช้มาโคร:

if (foo)
    SOME_MACRO();

"... เนื่องจากมาโครอาจกำหนดโค้ดได้หลายบรรทัดมาโครใช้do {...} while (0)กับหลายบรรทัดหรือไม่มันควรเป็นเพราะมันอยู่ในไกด์นำเที่ยวของเรา แต่ฉันควรตรวจสอบในกรณีที่ดีกว่า!"

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

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

เสียงรบกวนต่าง

เหตุผลหนึ่งที่ทำให้การปฏิบัติในการใช้เครื่องหมายวงเล็บสำหรับสายเดียวคือการลดเสียงรบกวนต่าง

นั่นคือการเปลี่ยนแปลง:

if (foo)
    bar();

ไปที่:

if (foo) {
    bar();
    baz();
}

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

• บรรทัดแสดงว่ามีการเปลี่ยนแปลงในการตรวจสอบโค้ดหากเครื่องมือการกระจายของคุณเป็นแบบใช้คำคุณสามารถเห็นได้อย่างง่ายดายว่ามีเพียงการเปลี่ยนรั้ง แต่ต้องใช้เวลามากขึ้นในการตรวจสอบว่าบรรทัดไม่เปลี่ยนแปลงเลยหรือไม่
  ต้องบอกว่าไม่ใช่เครื่องมือทั้งหมดที่รองรับการกระจายคำโดยใช้ diff (svn, git, hg ... ฯลฯ ) จะแสดงราวกับว่าทั้งบรรทัดเปลี่ยนไปแม้ว่าจะเป็นเครื่องมือแฟนซีบางครั้งคุณอาจต้องมองข้ามเส้นธรรมดาอย่างรวดเร็ว -based diff เพื่อดูว่ามีอะไรเปลี่ยนแปลง
• เครื่องมือการเพิ่มความคิดเห็น (เช่นgit blame) จะแสดงบรรทัดที่มีการเปลี่ยนแปลงทำให้การติดตามที่มาของขั้นตอนเพิ่มเติมเพื่อค้นหาการเปลี่ยนแปลงที่แท้จริง

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

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

มีข้อยกเว้นนี้สำหรับรหัสฐานที่มี{ในบรรทัดของตัวเอง - มันไม่ใช่ปัญหา

diff เสียงโต้แย้งไม่ถือถ้าคุณเขียนในรูปแบบนี้

if (foo)
{
    bar();
    baz();
}

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

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

if (debug)
   foo (4);

และปรากฎว่าคนที่เขียนมันได้นิยามfooว่าเป็นมาโคร แมโครที่มีโค้ดสองบรรทัด ifและแน่นอนเพียงครั้งแรกของทั้งสองสายเป็นเรื่องที่ (ดังนั้นบรรทัดที่สองจะถูกดำเนินการโดยไม่มีเงื่อนไข)

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

ตอนนี้ฉันเยื้องและใช้เครื่องมือจัดฟันแตกต่างจากคนอื่นอย่างเห็นได้ชัด สำหรับบรรทัดเดียวifฉันจะทำ:

if (debug) { foo (4); }

ดังนั้นจึงไม่ต้องใช้บรรทัดเพิ่มเติมใด ๆ เพื่อรวมเครื่องมือจัดฟัน

"ลุงบ๊อบ" ได้รับอนุญาตให้มีความคิดเห็นของเขาคุณได้รับอนุญาตให้มีความคิดเห็นของคุณ ไม่จำเป็นต้องท้าทายเขา

หากคุณต้องการอุทธรณ์ต่อผู้มีอำนาจโปรดนำ Chris Lattner ไปด้วย ใน Swift หากข้อความทำเครื่องหมายวงเล็บหาย แต่จะต้องใส่เครื่องหมายวงเล็บเสมอ ไม่มีการสนทนามันเป็นส่วนหนึ่งของภาษา ดังนั้นหาก "Uncle Bob" เริ่มลบเครื่องหมายวงเล็บรหัสจะหยุดรวบรวม

การใช้รหัสของคนอื่นและ "การกำจัดวงเล็บที่ไร้ประโยชน์" นั้นเป็นนิสัยที่ไม่ดี ทำให้เกิดการทำงานเพิ่มเติมเฉพาะเมื่อรหัสต้องได้รับการตรวจสอบและเมื่อมีการสร้างความขัดแย้งโดยไม่จำเป็น บางที "ลุงบ๊อบ" เป็นโปรแกรมเมอร์ที่ดีอย่างเหลือเชื่อซึ่งเขาไม่ต้องการการตรวจสอบโค้ด? ฉันเสียชีวิตไปหนึ่งสัปดาห์เพราะโปรแกรมเมอร์ยอดเยี่ยมคนหนึ่งเปลี่ยน "if (p! = NULL)" เป็น "if (! p)" โดยไม่ต้องตรวจสอบโค้ดซ่อนอยู่ในที่ที่เลวร้ายที่สุด

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

เหตุผลของฉันที่ไม่ลบวงเล็บปีกกาคือ:

1. ลดความเหนื่อยล้าในการตัดสินใจ หากคุณใช้เครื่องมือจัดฟันคุณไม่จำเป็นต้องตัดสินใจว่าคุณต้องการเครื่องมือจัดฟันหรือไม่

2. ลดความล่าช้าในการพัฒนา: แม้ว่าคุณจะพยายามแยกตรรกะหลาย ๆ เส้นทั้งหมดเป็นวิธีการในที่สุดก็ต้องแปลง braceless ถ้าเป็นแบบ braced หากเป็นการเพิ่มแบบตรรกะถ้าเป็นการเพิ่มตรรกะเป็นบิตที่น่ารำคาญของการพัฒนา ดังนั้นจึงมีความพยายามในการลบวงเล็บปีกกาและความพยายามในการเพิ่มพวกเขาอีกครั้งเมื่อคุณต้องการรหัสเพิ่มเติม เล็ก แต่น่ารำคาญ

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

Fwiw เราเห็นด้วยกับการประนีประนอมที่ทำให้พวกเขาอยู่ในบรรทัดเดียวไม่ได้ทำให้เงื่อนไขเบื้องต้นสั้น ๆ เช่นนี้ไม่สามารถอ่าน / ทำให้เสียสมาธิได้ เช่น

if (!param) { throw invalid_argument (blahblah); }
if (n < 2) { return 0; }
// real code for function starts here...

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

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

เมื่อดูวิดีโอนั้นในตอนนี้ฉันสังเกตว่าการกำจัดเครื่องมือจัดฟันทำให้ง่ายต่อการดูว่ารหัสยังคงต้องได้รับการปรับโครงสร้างใหม่หรือไม่ หากคุณต้องการเครื่องมือจัดฟันรหัสของคุณอาจจะดูสะอาดกว่านี้สักหน่อย

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

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

หากรหัสของคุณผ่านการทดสอบเป็นอย่างดี "บั๊ก" ชนิดนี้จะระเบิดออกมาในหน้า

การทำความสะอาดรหัสโดยการหลีกเลี่ยงวงเล็บเหลี่ยมที่ไร้ประโยชน์และน่าเกลียดนั้นเป็นวิธีปฏิบัติที่ฉันปฏิบัติตาม