คำถามติดแท็ก clean-code

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

8
การปรับเปลี่ยนพารามิเตอร์ขาเข้าเป็น antipattern หรือไม่? [ปิด]
ฉันกำลังเขียนโปรแกรมใน Java และฉันมักจะทำเช่นนี้: public OtherObject MyObject2OtherObject(MyObject mo){ ... Do the conversion return otherObject; } ในที่ทำงานใหม่รูปแบบคือ: public void MyObject2OtherObject(MyObject mo, OtherObject oo){ ... Do the conversion } สำหรับฉันมันส่งกลิ่นนิดหน่อยเพราะฉันคุ้นเคยกับการไม่เปลี่ยนพารามิเตอร์ขาเข้า การแก้ไขพารามิเตอร์ขาเข้านี้เป็น antipattern หรือไม่ มันมีข้อบกพร่องร้ายแรงบ้างไหม?

2
รหัส“ คุณสมบัติอิจฉา” คืออะไรและเหตุใดจึงถือว่าเป็นกลิ่นรหัส
นี้คำถามเกี่ยวกับ SOพูดคุยเกี่ยวกับการแก้ไขสิ่งที่คิด OP คือคุณลักษณะอิจฉารหัส อีกตัวอย่างหนึ่งที่ฉันเห็นวลีที่ดีนี้ถูกอ้างถึงในคำตอบที่ได้รับเมื่อเร็ว ๆ นี้ใน programmers.SE ถึงแม้ว่าผมจะไม่ได้ลดลงในความคิดเห็นที่จะตอบว่าขอให้ข้อมูลที่ผมคิดว่ามันจะมีการช่วยเหลือทั่วไปในการเขียนโปรแกรมต่อไปนี้ Q & A ที่จะเข้าใจสิ่งที่หมายโดยระยะคุณลักษณะอิจฉา โปรดแก้ไขแท็กเพิ่มเติมหากคุณคิดว่าเหมาะสม

14
แนวปฏิบัติที่ดีที่สุดในการสั่งซื้อพารามิเตอร์ในฟังก์ชั่นคืออะไร?
บางครั้ง (ไม่ค่อย) ดูเหมือนว่าการสร้างฟังก์ชั่นที่ใช้พารามิเตอร์ที่เหมาะสมเป็นเส้นทางที่ดีที่สุด อย่างไรก็ตามเมื่อฉันทำฉันรู้สึกเหมือนฉันมักจะเลือกการเรียงลำดับพารามิเตอร์แบบสุ่ม ฉันมักจะไปตาม "ลำดับความสำคัญ" โดยมีพารามิเตอร์ที่สำคัญที่สุดก่อน มีวิธีที่ดีกว่าในการทำเช่นนี้? มีวิธี "การปฏิบัติที่ดีที่สุด" ในการสั่งซื้อพารามิเตอร์ที่ช่วยเพิ่มความชัดเจนหรือไม่?

15
รหัสสะอาด: ฟังก์ชั่นที่มีพารามิเตอร์น้อย [ปิด]
ฉันอ่านบทแรกของรหัสสะอาดโดยโรเบิร์ตซีมาร์ตินและดูเหมือนว่าฉันจะค่อนข้างดี แต่ฉันมีข้อสงสัยในส่วนหนึ่งมันก็บอกว่ามันเป็นสิ่งที่ดี (ทางปัญญา) ว่าฟังก์ชั่นควรมีพารามิเตอร์น้อย เท่าที่เป็นไปได้มันยังแสดงให้เห็นว่าพารามิเตอร์ 3 ตัวหรือมากกว่านั้นมากเกินไปสำหรับฟังก์ชั่น (ซึ่งฉันคิดว่ามันพูดเกินจริงและอุดมการณ์) ดังนั้นฉันจึงเริ่มสงสัย ... ทั้งแนวปฏิบัติในการใช้ตัวแปรส่วนกลางและการส่งผ่านข้อโต้แย้งจำนวนมากในฟังก์ชั่นอาจเป็นวิธีปฏิบัติในการเขียนโปรแกรมที่ไม่ดี แต่การใช้ตัวแปรทั่วโลกสามารถลดจำนวนพารามิเตอร์ในฟังก์ชันได้อย่างมาก ... ดังนั้นฉันอยากได้ยินสิ่งที่คุณคิดเกี่ยวกับมันมันมีค่าใช้ตัวแปรทั่วโลกเพื่อลดจำนวนพารามิเตอร์ของฟังก์ชั่นหรือไม่? ในกรณีใดบ้าง สิ่งที่ฉันคิดคือมันขึ้นอยู่กับปัจจัยหลายประการ: ขนาดรหัสต้นฉบับ จำนวนพารามิเตอร์โดยเฉลี่ยของฟังก์ชั่น จำนวนฟังก์ชั่น ความถี่ที่ใช้ตัวแปรเดียวกัน ในความคิดของฉันถ้าขนาดซอร์สโค้ดมีขนาดค่อนข้างเล็ก (เช่นน้อยกว่า 600 บรรทัดของโค้ด) มีฟังก์ชั่นมากมายตัวแปรเดียวกันถูกส่งผ่านเป็นพารามิเตอร์และฟังก์ชั่นมีพารามิเตอร์มากมายจากนั้นใช้ตัวแปรทั่วโลกจะคุ้มค่า แต่ฉัน อยากรู้ว่า ... คุณแบ่งปันความคิดเห็นของฉัน? คุณคิดอย่างไรกับกรณีอื่นที่ซอร์สโค้ดใหญ่กว่า ฯลฯ ? ปล . ฉันเห็นโพสต์นี้ชื่อเรื่องนั้นคล้ายกันมาก แต่เขาไม่ถามสิ่งที่ฉันอยากรู้

20
คุณควรเขียนเอกสารที่ดีและรหัสสะอาดเพื่อเพิ่ม "Bus Factor" หรือไม่?
หนึ่งในเป้าหมายหลักของ บริษัท พัฒนาซอฟแวร์คือการเพิ่มของพวกเขาปัจจัย Busนี้จะยังสนับสนุนในการพูดคุยที่ถูกจัดขึ้นโดย Google นั่นหมายความว่าคุณควรเขียนโค้ดและจัดทำเอกสารทุกอย่างในแบบที่หากคุณใช้รถบัสในวันพรุ่งนี้โครงการก็ยังสามารถดำเนินต่อไปได้ กล่าวอีกนัยหนึ่งคุณควรทำให้โปรแกรมเมอร์ตัวอื่นสามารถเปลี่ยนได้อย่างง่ายดายด้วยทักษะที่คล้ายคลึงกับที่คุณตั้งไว้ การทำซ้ำได้นั้นไม่ได้ขัดกับความสนใจของนักพัฒนาหรือไม่? ในหนังสือกฎหมาย 48 ฉบับของกฎอำนาจ 11 ระบุว่าคุณควรพยายามให้ผู้คนพึ่งพาคุณเพื่อให้ได้มาซึ่งอำนาจซึ่งแปลเป็นรางวัลทางการเงิน นอกเหนือจากสถานการณ์สมมติที่คุณต้องการเอกสารประกอบสำหรับตัวคุณเองเพื่อดำเนินการโครงการหลังจากหยุดไป 6 เดือนดูเหมือนว่ามีความขัดแย้งทางผลประโยชน์ที่ชัดเจนระหว่างผู้พัฒนาและ บริษัท ซอฟต์แวร์ ดังนั้นในฐานะโปรแกรมเมอร์คุณควรเขียนเอกสารที่ยอดเยี่ยมและอ่านรหัสได้ง่ายสำหรับทุกคน หรือคุณควรเขียนรหัสและเอกสารในลักษณะที่ทำงานและตัวคุณเองสามารถเข้าใจได้ แต่คนอื่นอาจมีปัญหาในการทำความเข้าใจ?

8
ทำไมการเข้ารหัสชื่ออาร์กิวเมนต์ในชื่อฟังก์ชั่นจึงไม่เกิดขึ้นบ่อยนัก? [ปิด]
ในรหัสสะอาดผู้เขียนให้ตัวอย่างของ assertExpectedEqualsActual(expected, actual) VS assertEquals(expected, actual) กับอดีตอ้างว่ามีความชัดเจนมากขึ้นเพราะมันเอาความจำเป็นที่จะต้องจำที่ขัดแย้งไปและการใช้ผิดที่อาจเกิดขึ้นจากที่ แต่ฉันไม่เคยเห็นตัวอย่างของรูปแบบการตั้งชื่อเดิมในรหัสใด ๆ และดูหลังตลอดเวลา ทำไมผู้ไม่ใช้โคเดอร์จึงนำอดีตมาใช้ถ้าหากผู้เขียนอ้างว่าชัดเจนกว่าหลัง
47 clean-code 

13
ฉันจะแก้ไขเชนของ if-else ได้อย่างไรถ้าข้อความที่เป็นไปตามหลักการ Clean Code ของลุงบ็อบ?
ฉันกำลังพยายามทำตามคำแนะนำที่ชัดเจนของลุงบ็อบและโดยเฉพาะอย่างยิ่งเพื่อให้วิธีการสั้น ฉันพบว่าตัวเองไม่สามารถตัดทอนตรรกะนี้ได้แม้ว่า: if (checkCondition()) {addAlert(1);} else if (checkCondition2()) {addAlert(2);} else if (checkCondition3()) {addAlert(3);} else if (checkCondition4()) {addAlert(4);} ฉันไม่สามารถลบ elses และแยกสิ่งทั้งหมดออกเป็นบิตขนาดเล็กทำให้ "else" ใน "else if" ช่วยประสิทธิภาพการทำงาน - การประเมินเงื่อนไขเหล่านั้นมีราคาแพงและถ้าฉันสามารถหลีกเลี่ยงการประเมินเงื่อนไขด้านล่างได้ เป็นจริงฉันต้องการหลีกเลี่ยงพวกเขา แม้แต่การพูดเชิงความหมายการประเมินเงื่อนไขถัดไปหากพบก่อนหน้านี้ก็ไม่สมเหตุสมผลจากมุมมองทางธุรกิจ แก้ไข: คำถามนี้ถูกระบุว่าเป็นที่ซ้ำกันเป็นไปได้ของวิธีที่สง่างามในการจับถ้า (ถ้าอื่น) อื่น ฉันเชื่อว่านี่เป็นคำถามที่แตกต่างกัน (คุณสามารถเห็นได้ด้วยการเปรียบเทียบคำตอบของคำถามเหล่านั้น) คำถามของฉันคือการตรวจสอบสำหรับเงื่อนไขแรกยอมรับที่จะจบได้อย่างรวดเร็ว คำถามที่เชื่อมโยงนั้นกำลังพยายามยอมรับเงื่อนไขทั้งหมดเพื่อที่จะทำอะไรสักอย่าง (เห็นได้ดีขึ้นในคำตอบสำหรับคำถามนี้: https://softwareengineering.stackexchange.com/a/122625/96955 )

3
สถาปัตยกรรมสะอาดของลุงบ๊อบ - คลาสเอนทิตี้ / โมเดลสำหรับแต่ละเลเยอร์
พื้นหลัง : ฉันกำลังพยายามใช้สถาปัตยกรรมที่สะอาดของลุงบ็อบในแอพ Android ของฉัน ฉันศึกษาโครงการโอเพนซอร์ซจำนวนมากที่พยายามแสดงวิธีการที่ถูกต้องและฉันพบว่ามีการนำไปใช้ที่น่าสนใจโดยใช้ RxAndroid สิ่งที่ฉันสังเกตเห็น: ในทุกเลเยอร์ (งานนำเสนอโดเมนและข้อมูล) มีคลาสโมเดลสำหรับเอนทิตีเดียวกัน (พูดถึง UML) นอกจากนี้ยังมีคลาส mapper ที่ดูแลการเปลี่ยนแปลงของวัตถุเมื่อใดก็ตามที่ข้อมูลข้ามเขตแดน (จากชั้นหนึ่งไปอีกชั้นหนึ่ง) คำถาม: มันจำเป็นต้องมีคลาสของโมเดลในทุกเลเยอร์หรือไม่เมื่อฉันรู้ว่าพวกมันทั้งหมดจะจบลงด้วยคุณลักษณะเดียวกันหากจำเป็นต้องใช้การดำเนินการ CRUD ทั้งหมดหรือไม่ หรือว่าเป็นกฎหรือแนวปฏิบัติที่ดีที่สุดเมื่อใช้สถาปัตยกรรมสะอาดหรือไม่

8
การแปลงคำสั่ง IF
ดังนั้นฉันจึงเขียนโปรแกรมมาหลายปีแล้วและเพิ่งเริ่มใช้ ReSharper มากขึ้น สิ่งหนึ่งที่ ReSharper แนะนำให้ฉันเสมอคือ "กลับด้าน" ถ้า "คำสั่งเพื่อลดการซ้อน" สมมติว่าฉันมีรหัสนี้: foreach (someObject in someObjectList) { if(someObject != null) { someOtherObject = someObject.SomeProperty; } } และ ReSharper จะแนะนำให้ฉันทำสิ่งนี้: foreach (someObject in someObjectList) { if(someObject == null) continue; someOtherObject = someObject.SomeProperty; } ดูเหมือนว่า ReSharper จะแนะนำให้ฉันย้อนกลับ IFs ไม่ว่าจะทำรังมากแค่ไหนก็ตาม ปัญหานี้คือฉันชอบทำรังในสถานการณ์อย่างน้อยบางครั้ง สำหรับฉันนั้นดูเหมือนง่ายต่อการอ่านและเข้าใจว่าเกิดอะไรขึ้นในบางสถานที่ นี่ไม่ใช่กรณีเสมอไป แต่ฉันรู้สึกสะดวกสบายในการทำรังในบางครั้ง คำถามของฉันคือ: …

14
การล้างโค้ดของคนอื่นสำคัญอย่างไรเมื่อต้องเผชิญกับกำหนดเวลาที่แน่นหนา [ปิด]
(ฉันกำลังพูดถึงโค้ด HTML / CSS (ไม่ใช่ภาษาการเขียนโปรแกรม) แต่ฉันคิดว่าเรายังต้องเผชิญกับปัญหาเช่นเดียวกับโปรแกรมเมอร์) ฉันเป็นนักออกแบบ front-end อาวุโสในทีมและฉันมักจะต้องทำผลงานใหม่ของรุ่นน้องในเวลาที่ จำกัด ฉันกำลังเผชิญกับปัญหาที่ 2: สไตล์การเขียนโค้ดของพวกเขาค่อนข้างยุ่งเหยิง ความสวยงามไม่ดี ฉันพบสไตล์การเข้ารหัสของพวกเขาว่าเป็นถุงผสมที่ไม่มีแบบแผน / มาตรฐานที่เหมาะสม ฉันขาดการทำความสะอาดรหัสหรือจัดการกับรหัสของพวกเขา (แม้แต่การคัดลอกวิธีที่พวกเขาทำ) ฉันคิดว่ามันน่าหงุดหงิดที่จะทำตามสไตล์การเขียนรหัสเพราะฉันรู้สึกว่าฉันอาจเรียนรู้นิสัยที่ไม่ดี แต่นั่นเป็นวิธีที่เร็วที่สุดในการประชุมกำหนดเวลา สำหรับผู้ที่มีประสบการณ์มากขึ้นซึ่งมีประสิทธิภาพมากขึ้น? ฉันควรบันทึกการล้างข้อมูลไว้เพื่อใช้ในภายหลังหรือไม่ หรือทำความสะอาดระหว่างทางเมื่อฉันทำการเปลี่ยนแปลง? (ฉันไม่ต้องการที่จะฟังดูหยิ่ง แต่นั่นคือความจริงมันจะใช้เวลาหลายปีกว่าในการเขียนโค้ดที่ดีกว่าฉันรู้ฉันเขียนโค้ดยุ่ง ๆ เมื่อฉันเริ่มต้น)

5
ผ่าน ID หรือวัตถุ?
เมื่อระบุวิธีตรรกะทางธุรกิจเพื่อรับเอนทิตีโดเมนพารามิเตอร์ควรยอมรับวัตถุหรือ ID หรือไม่ ตัวอย่างเช่นเราควรทำสิ่งนี้: public Foo GetItem(int id) {} หรือสิ่งนี้: public Foo GetItem(Foo foo) {} ฉันเชื่อในการส่งวัตถุไปรอบ ๆ อย่างครบถ้วน แต่สิ่งที่เกี่ยวกับกรณีนี้ที่เราได้รับวัตถุและเรารู้ ID เท่านั้น ผู้โทรควรสร้าง Foo ที่ว่างเปล่าและตั้ง ID หรือควรส่ง ID ไปที่เมธอด? เนื่องจาก Foo ที่เข้ามาจะว่างเปล่ายกเว้น ID ฉันไม่เห็นประโยชน์ของผู้โทรที่ต้องสร้าง Foo และตั้ง ID เมื่อมันสามารถส่ง ID ไปยังวิธี GetItem ()

14
มีประโยชน์อะไรบ้างที่ทำให้มัวเมากับการสร้างโค้ด“ ดูสวย”
บางครั้งฉันใช้เวลา (ชั่วโมง) ที่ไร้สาระในการสร้างโค้ด "ดูน่ารัก" ฉันหมายถึงการทำให้สิ่งต่าง ๆ ดูสมมาตร จริง ๆ แล้วฉันจะเลื่อนดูทั้งชั้นอย่างรวดเร็วเพื่อดูว่ามีสิ่งใดที่กระโดดออกมาโดยไม่มองว่า "สวย" หรือ "สะอาด" ฉันจะเสียเวลาหรือเปล่า? พฤติกรรมแบบนี้มีคุณค่าหรือไม่? บางครั้งฟังก์ชั่นหรือการออกแบบของรหัสจะไม่เปลี่ยนแปลงฉันจะเพียงแค่ปรับโครงสร้างใหม่เพื่อให้ดูดีขึ้น ฉันแค่เป็นโรค OCD โดยสิ้นเชิงหรือมีประโยชน์ซ่อนอยู่ในนี้บ้างไหม
34 clean-code 

6
บรรทัดเพิ่มเติมในบล็อกและพารามิเตอร์เพิ่มเติมในรหัสที่สะอาด
บริบท ในClean Codeหน้า 35 บอกไว้ นี่ก็หมายความว่าบล็อกภายในถ้าคำสั่งคำสั่งอื่นในขณะที่คำสั่งและอื่น ๆ ควรมีความยาวหนึ่งบรรทัด อาจเป็นไปได้ว่าสายควรจะเรียกฟังก์ชั่น สิ่งนี้ไม่เพียงทำให้ฟังก์ชั่นการปิดล้อมมีขนาดเล็ก แต่ยังเพิ่มมูลค่าเอกสารเพราะฟังก์ชั่นที่เรียกว่าภายในบล็อกสามารถมีชื่อที่สื่อความหมายได้ดี ฉันเห็นด้วยอย่างสมบูรณ์ซึ่งทำให้รู้สึกมาก ต่อมาในหน้า 40 มันพูดเกี่ยวกับข้อโต้แย้งฟังก์ชั่น จำนวนอาร์กิวเมนต์ที่เหมาะสมที่สุดสำหรับฟังก์ชันคือศูนย์ (niladic) ถัดมาคือหนึ่ง (monadic) ตามมาด้วยสอง (dyadic) ควรหลีกเลี่ยงการโต้แย้งสามครั้ง (triadic) หากเป็นไปได้ มากกว่าสาม (polyadic) ต้องมีเหตุผลพิเศษมาก - จากนั้นไม่ควรใช้ต่อไป การโต้แย้งยาก พวกเขาใช้พลังความคิดมากมาย ฉันเห็นด้วยอย่างสมบูรณ์ซึ่งทำให้รู้สึกมาก ปัญหา อย่างไรก็ตามบ่อยครั้งที่ฉันพบว่าตัวเองกำลังสร้างรายการจากรายการอื่นและฉันจะต้องอยู่กับหนึ่งในสองความชั่วร้าย ฉันใช้สองบรรทัดในบล็อกหนึ่งรายการสำหรับสร้างสิ่งหนึ่งสำหรับเพิ่มไปยังผลลัพธ์: public List<Flurp> CreateFlurps(List<BadaBoom> badaBooms) { List<Flurp> flurps = new List<Flurp>(); foreach (BadaBoom badaBoom in badaBooms) …
33 clean-code  solid 

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

7
มันเป็นกลิ่นรหัสที่จะตั้งค่าสถานะในวงเพื่อใช้ในภายหลัง?
ฉันมีรหัสบางส่วนที่ฉันทำซ้ำแผนที่จนกว่าเงื่อนไขบางอย่างจะเป็นจริงและต่อมาก็ใช้เงื่อนไขนั้นเพื่อทำบางสิ่งเพิ่มเติม ตัวอย่าง: Map<BigInteger, List<String>> map = handler.getMap(); if(map != null && !map.isEmpty()) { for (Map.Entry<BigInteger, List<String>> entry : map.entrySet()) { fillUpList(); if(list.size() > limit) { limitFlag = true; break; } } } else { logger.info("\n>>>>> \n\t 6.1 NO entries to iterate over (for given FC and target) \n"); } if(!limitFlag) …

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.