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

ฉันมักจะพบว่าตัวเองต่อสู้กับเรื่องนี้ ... พยายามหาสมดุลระหว่างลอง / จับและรหัสไม่เป็นระเบียบลามกของแท็บวงเล็บและข้อยกเว้นถูกโยนกลับกองโทรเช่นมันฝรั่งร้อน ตัวอย่างเช่นฉันมีแอพที่ฉันกำลังพัฒนาอยู่ตอนนี้ซึ่งใช้ SQLite ฉันมีอินเทอร์เฟซฐานข้อมูลที่เป็นนามธรรมการเรียกใช้ SQLite และแบบจำลองที่ยอมรับสิ่งต่าง ๆ ที่จะเข้า / ออกจากฐานข้อมูล ... ดังนั้นหาก / เมื่อเกิดข้อยกเว้น SQLite ขึ้นมามันจะต้องถูกโยนขึ้นสู่รุ่น (ซึ่งเรียกว่า ) ใครจะต้องส่งมันให้ใครก็ตามที่เรียกว่า AddRecord / DeleteRecord / อะไรก็ตาม ... ฉันเป็นแฟนตัวยงของข้อยกเว้นซึ่งตรงกันข้ามกับการส่งคืนรหัสข้อผิดพลาดเนื่องจากรหัสข้อผิดพลาดสามารถถูกละเว้นลืม ฯลฯ ได้ในขณะที่การจัดการข้อยกเว้นเป็นหลัก (ได้รับฉันสามารถจับและย้ายได้ทันที ... ) ฉัน บางอย่างจะต้องมีวิธีที่ดีกว่าสิ่งที่ฉันเกิดขึ้นตอนนี้ แก้ไข: ฉันควรจะใช้ถ้อยคำนี้แตกต่างกันเล็กน้อย ฉันเข้าใจที่จะโยนเป็นประเภทที่แตกต่างกันและเช่นนั้นฉันพูดได้ไม่ดีและนั่นเป็นความผิดของฉันเอง คำถามของฉันคือ ... จะรักษาความสะอาดโค้ดเมื่อทำเช่นนั้นได้อย่างไร มันเริ่มรู้สึกเกะกะอย่างมากกับฉันหลังจากนั้นไม่นาน

15 code-quality  exceptions  readability  clean-code 

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

14 code-quality  code-reviews  clean-code  team-leader  process-improvement 

เพื่อหลีกเลี่ยงตัวเลขเวทย์มนตร์เรามักได้ยินว่าเราควรให้ชื่อที่มีความหมายตามตัวอักษร เช่น: //THIS CODE COMES FROM THE CLEAN CODE BOOK for (int j = 0; j < 34; j++) { s += (t[j] * 4) / 5; } -------------------- Change to -------------------- int realDaysPerIdealDay = 4; const int WORK_DAYS_PER_WEEK = 5; int sum = 0; for (int j = 0; …

14 coding-style  code-quality  clean-code  code-reviews 

ในหน้า 45 ของรหัสสะอาดของโรเบิร์ตซี. มาร์ติน: คู่มืองานฝีมือซอฟต์แวร์เปรียวมาร์ตินเขียนว่าควรหลีกเลี่ยงข้อโต้แย้งเกี่ยวกับผลลัพธ์ ฉันมีปัญหาในการเข้าใจความหมายของ "เอาท์พุทอาร์กิวเมนต์" และทำไมพวกเขาควรหลีกเลี่ยง ตัวอย่างเช่นมาร์ตินสำหรับอาร์กิวเมนต์ส่งออกเรียกฟังก์ชันappendFooter(s); public void appendFooter(StringBuffer report)การปรับปรุงรหัสของเขาคือreport.appendFooter(); อาจเป็นเพราะการขาดบริบทของรหัส แต่ฉันไม่เห็นว่าการใช้ข้อโต้แย้งเอาท์พุทจะถือว่าการเข้ารหัสไม่ดี ใครช่วยอธิบายแนวคิดหรือให้ตัวอย่างโค้ดเพิ่มเติมเพื่อให้เข้าใจสิ่งนี้ ฟังก์ชั่นต่อไปนี้จะถือว่าเป็นตัวอย่างของโค้ดที่ไม่สะอาดตามหลักการข้างต้นหรือไม่ int[] numberArray = {3, 5, 7, 1}; sortArray(numberArray); ถ้าข้างต้นเป็นการละเมิดหลักการของ Martin ที่ไม่ได้ใช้อาร์กิวเมนต์เอาท์พุทจะดีกว่าไหมถ้ามีวัตถุที่มีอาร์เรย์เป็นเขตข้อมูลและฟังก์ชันที่สามารถเรียกให้เรียงลำดับอาร์เรย์ได้ ObjectWithArrayField numberArray = new ObjectWithArrayField(3, 5, 7, 1); numberArray.sort();

14 java  clean-code 

ในรหัสที่สะอาดมันถูกเขียนขึ้นว่า "จำนวนอาร์กิวเมนต์ที่เหมาะสมที่สุดสำหรับฟังก์ชั่นเป็นศูนย์" เหตุผลที่อธิบายและเข้าใจได้ง่าย สิ่งที่ฉันตามมาคือเทคนิคในการปรับเปลี่ยนวิธีด้วยอาร์กิวเมนต์ 4 ตัวขึ้นไปเพื่อแก้ปัญหานี้ วิธีหนึ่งคือการแยกอาร์กิวเมนต์ไปยังคลาสใหม่ แต่นั่นจะนำไปสู่การระเบิดของคลาสอย่างแน่นอนหรือไม่ และคลาสเหล่านั้นมีแนวโน้มที่จะจบลงด้วยชื่อที่ละเมิดกฎการตั้งชื่อบางอย่าง (ลงท้ายด้วย "Data" หรือ "Info" ฯลฯ ) หรือไม่ อีกเทคนิคหนึ่งคือการทำให้ตัวแปรที่ใช้โดยหลายฟังก์ชั่นเป็นตัวแปรสมาชิกส่วนตัวเพื่อหลีกเลี่ยงการผ่านตัวแปรเหล่านั้น แต่นั่นเป็นการขยายขอบเขตของตัวแปรซึ่งอาจเป็นการเปิดให้ฟังก์ชั่นที่ไม่จำเป็นต้องใช้จริง เพียงมองหาวิธีลดอาร์กิวเมนต์ของฟังก์ชันให้เล็กที่สุดโดยยอมรับเหตุผลว่าทำไมจึงเป็นความคิดที่ดี

13 functions  clean-code 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน10 เดือนที่ผ่านมา ฉันอยู่ในงานจริงครั้งแรกของฉันในฐานะโปรแกรมเมอร์และสิ่งที่ฉันเห็นก็คือรหัส "Big Ball of Mud" (ไม่มีความคิดเห็นที่เป็นประโยชน์ด้วย) แต่ฉันชอบทำโค้ดที่สะอาดและมันยากสำหรับฉันที่จะเขียนโค้ดแย่ ทาง ฉันกำลังค้นหากรณีศึกษาบางส่วนที่การใช้โค้ดสะอาด (ฉันเห็นคำจำกัดความต่าง ๆ ที่นี่คือโค้ดสะอาด) ปรับปรุงการพัฒนาและบำรุงรักษาได้

13 clean-code  case-studies 

ฉันเรียนรู้เรื่องการทำความสะอาดและด้วยเหตุนี้ฉันจึงคิดใหม่อย่างมากเกี่ยวกับวิธีการออกแบบและเขียนซอฟต์แวร์ สิ่งที่ฉันยังคงต่อสู้ด้วยมีไว้สำหรับกฎเกณฑ์ทางธุรกิจเช่น "ในการอัปเดตการบันทึกบางรายการก่อนอื่นโหลดรายการทั้งหมดที่ฉันได้รับอนุญาตให้ดู / แก้ไข ฯลฯ ยืนยันว่ารายการนี้อยู่ในรายการ และหมวดหมู่รายการไม่ได้ถูกล็อกจากการใช้งาน (และกฎอื่น ๆ ฯลฯ ) ".. เนื่องจากเป็นกฎธุรกิจ (ซับซ้อน แต่ไม่ผิดปรกติ) ดังนั้นจึงควรจัดการในโดเมนแอปพลิเคชันแทนที่จะผลักดันตรรกะทางธุรกิจลงใน ชั้น db / การคงอยู่ อย่างไรก็ตามดูเหมือนว่าสำหรับฉันที่จะตรวจสอบเงื่อนไขเหล่านี้ได้อย่างมีประสิทธิภาพมันมักจะได้รับการจัดการที่ดีที่สุดกับแบบสอบถาม DB ที่สร้างขึ้นมาอย่างดีแทนที่จะโหลดข้อมูลทั้งหมดลงในโดเมนแอปพลิเคชัน ... หากไม่มีการปรับให้เหมาะสมก่อนเวลาอันควรแนวทางที่แนะนำหรือบทความบ็อบลุงจัดการกับคำถามนี้คืออะไร หรือเขาจะพูดว่า "ตรวจสอบในโดเมนจนกว่ามันจะกลายเป็นปัญหา" ?? ฉันกำลังดิ้นรนเพื่อค้นหาตัวอย่าง / ตัวอย่างที่ดีสำหรับสิ่งอื่นใดนอกเหนือจากกรณีพื้นฐานที่สุดของการใช้งาน ปรับปรุง: สวัสดีทุกคนขอบคุณสำหรับการตอบกลับ ฉันควรจะชัดเจนกว่าฉันเขียนซอฟต์แวร์ (ส่วนใหญ่เป็นแอปพลิเคชันเว็บ) เป็นเวลานานและมีประสบการณ์แล้วและเห็นด้วยกับทุกหัวข้อที่คุณอธิบายร่วมกัน (ตรวจสอบโดยแบ็กเอนด์ไม่เชื่อถือข้อมูลลูกค้าโดยทั่วไป ไล่ล่าประสิทธิภาพดิบเมื่อจำเป็นเท่านั้น แต่รับทราบจุดแข็งของเครื่องมือ db เมื่อมีให้ใช้ ฯลฯ ) และได้ผ่านวงจรการเรียนรู้ของนักพัฒนาของ "โยนทั้งหมดเข้าด้วยกัน" เพื่อ "สร้างตัวควบคุมไขมันยักษ์ด้วยแอปพลิเคชัน N-tiers" และตอนนี้ชอบและตรวจสอบสไตล์ความรับผิดชอบที่สะอาด …

13 clean-code  domain-model  validation  business-rules 

ฉันมีชั้นเรียนที่ใช้ในการประมวลผลการชำระเงินของลูกค้า ทั้งหมดยกเว้นหนึ่งในวิธีการของคลาสนี้จะเหมือนกันสำหรับลูกค้าทุกคนยกเว้นวิธีที่คำนวณ (ตัวอย่าง) จำนวนผู้ใช้ของลูกค้าที่ค้างชำระ สิ่งนี้อาจแตกต่างกันอย่างมากจากลูกค้าไปยังลูกค้าและไม่มีวิธีง่ายๆในการจับตรรกะของการคำนวณในบางสิ่งบางอย่างเช่นไฟล์คุณสมบัติเนื่องจากอาจมีปัจจัยที่กำหนดเองจำนวนเท่าใดก็ได้ ฉันสามารถเขียนรหัสน่าเกลียดที่เปลี่ยนตาม customerID: switch(customerID) { case 101: .. do calculations for customer 101 case 102: .. do calculations for customer 102 case 103: .. do calculations for customer 103 etc } แต่สิ่งนี้ต้องการการสร้างคลาสใหม่ทุกครั้งที่เราได้ลูกค้าใหม่ อะไรคือวิธีที่ดีกว่า [แก้ไข] บทความ "ซ้ำกัน" แตกต่างอย่างสิ้นเชิง ฉันไม่ได้ถามว่าจะหลีกเลี่ยงคำสั่ง switch ได้อย่างไรฉันกำลังขอการออกแบบที่ทันสมัยที่ใช้กับกรณีนี้ได้ดีที่สุด - ซึ่งฉันสามารถแก้ไขได้ด้วยคำสั่ง switch หากฉันต้องการเขียนรหัสไดโนเสาร์ ตัวอย่างที่ให้ไว้มีทั่วไปและไม่เป็นประโยชน์เนื่องจากพวกเขาบอกว่า "เฮ้สวิตช์ทำงานได้ค่อนข้างดีในบางกรณีไม่ใช่ในบางกรณี" …

12 design-patterns  clean-code  code-reuse 

มาโครที่รู้จักกันในชื่อlikelyและunlikelyมาโครช่วยให้คอมไพเลอร์ทราบว่าifจะป้อนหรือข้าม การใช้มันจะส่งผลในการปรับปรุงประสิทธิภาพ (ค่อนข้างเล็กน้อย) ฉันเริ่มใช้มันเมื่อไม่นานมานี้และฉันไม่แน่ใจว่าควรใช้คำใบ้ดังกล่าวบ่อยเพียงใด ฉันกำลังใช้กับการตรวจสอบข้อผิดพลาดifs unlikelyซึ่งมักจะถูกทำเครื่องหมายเป็น ตัวอย่างเช่น: mem = malloc(size); if (unlikely(mem == NULL)) goto exit_no_mem; ดูเหมือนว่าจะใช้ได้ แต่การตรวจสอบข้อผิดพลาดifเกิดขึ้นบ่อยครั้งดังนั้นจึงใช้มาโครดังกล่าว คำถามของฉันคือมันมีมากเกินไปlikelyและunlikelyแมโครในทุกการตรวจสอบข้อผิดพลาดif? ในขณะที่เราอยู่ที่นี่พวกเขามักจะใช้ที่อื่นที่ไหน? ในการใช้งานปัจจุบันของฉันมันอยู่ในไลบรารีที่ทำให้เกิดนามธรรมจากระบบย่อยเรียลไทม์ดังนั้นโปรแกรมจะกลายเป็นแบบพกพาระหว่าง RTAI, QNX และอื่น ๆ ที่กล่าวว่าฟังก์ชั่นส่วนใหญ่ค่อนข้างเล็กและเรียกฟังก์ชั่นอื่น ๆ หนึ่งหรือสองโดยตรง หลายคนมีstatic inlineฟังก์ชั่น อย่างแรกเลยไม่ใช่แอพพลิเคชั่นที่ฉันสามารถโพรไฟล์ได้ มันไม่มีเหตุผลที่จะ "ระบุคอขวด" เนื่องจากเป็นห้องสมุดไม่ใช่แอปพลิเคชันแบบสแตนด์อโลน ประการที่สองมันคล้ายกับ "ฉันรู้ว่ามันไม่น่าเป็นไปได้ฉันก็จะบอกให้คอมไพเลอร์" ifฉันไม่แข็งขันพยายามที่จะเพิ่มประสิทธิภาพ

12 c  performance  clean-code 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา ขณะนี้ฉันกำลังฝึกงานใน บริษัท ขนาดใหญ่และพวกเขาอยู่ระหว่างการเปลี่ยนแปลงโครงสร้างการส่งมอบซอฟต์แวร์จำนวนมาก (ย้ายไปที่เปรียว) ในช่วงสองสามเดือนที่ผ่านมาฉันสังเกตเห็นความผูกพันทางศาสนานี้กับClean Codeการฝึกฝนและหนังสือเล่มนี้ เป็นเหมือนคัมภีร์ไบเบิลสำหรับนักพัฒนา ตอนนี้หนึ่งในคุณสมบัติที่สำคัญที่สุดของรหัสสะอาดคือรหัสอธิบายตนเองซึ่งตั้งอยู่บนพื้นฐานของการตั้งชื่อที่เข้าใจได้และการแยกตัวประกอบอย่างเข้มงวด ตามด้วยno commentingกฎ ฉันเข้าใจว่าโค้ดที่สะอาดนี้เป็นการลงทุนระยะยาวซึ่งจะช่วยให้การบำรุงรักษาและการปรับปรุงโค้ดง่ายขึ้น แต่ ... มันคุ้มค่าจริง ๆ ไหม ทุกคนจะแบ่งปันประสบการณ์ของพวกเขาเกี่ยวกับรหัสสะอาดและความคิดเห็นใด ๆ ไม่ว่าฉันจะเป็นเพียงแค่หัวโบราณเกินไปหรือเป็นเพียงแนวโน้มชั่วคราว

11 programming-practices  agile  clean-code 

สิ่งใดที่จะถือว่าได้รับการบำรุงรักษามากขึ้น if (a == b) c = true; else c = false; หรือ c = (a == b); ฉันลองดูใน Code Complete แต่ไม่พบคำตอบ ฉันคิดว่าอันแรกสามารถอ่านได้มากขึ้น (คุณสามารถอ่านออกเสียงออกมาได้ดัง ๆ ) ซึ่งฉันคิดว่าทำให้สามารถบำรุงรักษาได้มากขึ้น อันที่สองมีความเหมาะสมมากกว่าและลดรหัส แต่ฉันไม่แน่ใจว่ามันจะบำรุงรักษาได้สำหรับนักพัฒนา C # (ฉันคาดว่าจะเห็นสำนวนนี้มากขึ้นเช่น Python)

11 .net  code-quality  readability  maintainability  clean-code 

ฉันสังเกตเห็นบางอย่างในรหัสของฉันในโครงการต่าง ๆ ที่ดูเหมือนว่ากลิ่นรหัสให้ฉันและสิ่งที่ไม่ดีที่จะทำ แต่ฉันไม่สามารถจัดการกับมัน ในขณะที่พยายามเขียน "รหัสสะอาด" ฉันมักจะใช้วิธีส่วนตัวมากเกินไปเพื่อให้อ่านรหัสได้ง่ายขึ้น ปัญหาคือรหัสนั้นสะอาดกว่า แต่ก็ยากกว่าในการทดสอบ (ใช่ฉันรู้ว่าฉันสามารถทดสอบวิธีการส่วนตัว ... ) และโดยทั่วไปดูเหมือนว่านิสัยที่ไม่ดีสำหรับฉัน นี่คือตัวอย่างของคลาสที่อ่านข้อมูลบางอย่างจากไฟล์. csv และส่งคืนกลุ่มลูกค้า (วัตถุอื่นที่มีเขตข้อมูลและแอตทริบิวต์ต่าง ๆ ) public class GroupOfCustomersImporter { //... Call fields .... public GroupOfCustomersImporter(String filePath) { this.filePath = filePath; customers = new HashSet<Customer>(); createCSVReader(); read(); constructTTRP_Instance(); } private void createCSVReader() { //.... } private void …

11 design-patterns  object-oriented-design  clean-code  encapsulation 

ด้วย SDK สาธารณะของเราเรามักจะต้องการส่งข้อความที่ให้ข้อมูลอย่างมากเกี่ยวกับสาเหตุที่เกิดข้อยกเว้น ตัวอย่างเช่น: if (interfaceInstance == null) { string errMsg = string.Format( "Construction of Action Argument: {0}, via the empty constructor worked, but type: {1} could not be cast to type {2}.", ParameterInfo.Name, ParameterInfo.ParameterType, typeof(IParameter) ); throw new InvalidOperationException(errMsg); } อย่างไรก็ตามสิ่งนี้มีแนวโน้มที่จะทำให้การไหลเวียนของรหัสแย่ลงเนื่องจากมีแนวโน้มที่จะให้ความสำคัญกับข้อความแสดงข้อผิดพลาดมากกว่าที่จะทำโค้ด เพื่อนร่วมงานเริ่ม refactoring ข้อยกเว้นบางอย่างให้กับสิ่งนี้: if (interfaceInstance == null) throw …

11 c#  .net  clean-code  exception-handling 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันเจอเงื่อนไขต่อไปนี้ในโปรแกรมที่ฉันได้ยึดครองจากผู้พัฒนารายอื่น: if (obj.Performance <= LOW_PERFORMANCE) { obj.NeedsChange = true; } else { obj.NeedsChange = false; } ฉันเชื่อว่ารหัสนี้ซ้ำซ้อนและน่าเกลียดดังนั้นฉันจึงเปลี่ยนเป็นสิ่งที่ฉันคิดว่าเป็นการมอบหมายบูลีนอย่างง่ายจากการเปรียบเทียบ: obj.NeedsChange = obj.Performance <= LOW_PERFORMANCE; เมื่อเห็นสิ่งนี้มีคนกำลังตรวจสอบรหัสของฉันแสดงความคิดเห็นว่าแม้ว่าการเปลี่ยนแปลงของฉันจะถูกต้องตามหน้าที่ แต่อาจทำให้ผู้อื่นดูสับสน เขาเชื่อว่าการใช้ผู้ประกอบการสามคนทำให้การบ้านนี้ชัดเจนยิ่งขึ้นในขณะที่ฉันไม่ชอบการเพิ่มรหัสซ้ำซ้อนเพิ่มเติม: obj.NeedsChange = (obj.Performance <= LOW_PERFORMANCE) ? true : false; เหตุผลของเขาคือการทำบางสิ่งด้วยวิธีที่รัดกุมที่สุดนั้นไม่คุ้มค่าถ้ามันทำให้ผู้พัฒนารายอื่นต้องหยุดและไขปริศนาสิ่งที่คุณทำ คำถามจริงที่นี่คือวิธีใดในสามวิธีในการกำหนดค่าให้กับบูลีนobj.NeedsChangeที่ชัดเจนที่สุดและสามารถบำรุงรักษาได้มากที่สุด

10 clean-code  maintainability  boolean 

ฉันมีรหัสต่อไปนี้: public void moveCameraTo(Location location){ moveCameraTo(location.getLatitude(), location.getLongitude()); } public void moveCameraTo(double latitude, double longitude){ LatLng latLng = new LatLng(latitude, longitude); moveCameraTo(latLng); } public void moveCameraTo(LatLng latLng){ GoogleMap googleMap = getGoogleMap(); cameraUpdate = CameraUpdateFactory.newLatLngZoom(latLng, INITIAL_MAP_ZOOM_LEVEL); googleMap.moveCamera(cameraUpdate); } ฉันคิดว่าด้วยวิธีนี้ฉันกำจัดความรับผิดชอบในการรู้ว่าสิ่งที่อยู่LatLngในชั้นเรียนอื่นเช่น และคุณไม่จำเป็นต้องเตรียมข้อมูลก่อนเรียกฟังก์ชั่น คุณคิดอย่างไร? วิธีนี้มีชื่อหรือไม่? เป็นการฝึกที่ไม่ดีจริง ๆ หรือ?

10 design  design-patterns  clean-code  code-smell  bad-code