คำถามติดแท็ก refactoring

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

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

3
มีวิธีใดที่ดีในการจัดระเบียบไฟล์อินพุต (Makefiles, SConstruct, CMakeLists.txt และอื่น ๆ ) เพื่อสร้างซอฟต์แวร์อัตโนมัติ
สิ่งหนึ่งที่ฉันต้องการทำกับรหัสของฉันคือการทำให้แน่ใจว่ามัน refactored เป็นชิ้นจัดการ อย่างไรก็ตามเมื่อมันมาถึงการสร้างซอฟต์แวร์ฉันพบว่าสิ่งที่สร้างซอฟต์แวร์อัตโนมัติที่ฉันใช้ (เมื่อเร็ว ๆ นี้มันเป็น GNU Make หรือ SCons) กลายเป็นความยุ่งเหยิงอย่างสมบูรณ์ ไฟล์อินพุตมีลักษณะเหมือนสคริปต์แบบยาวที่ดูเหมือนจะท้าทายการปรับโครงสร้างใหม่ได้ง่าย ฉันต้องการที่จะ refactor พวกเขาในทางใดทางหนึ่ง แต่แนวคิดของ "ฟังก์ชั่น" ไม่ได้ทำงานในลักษณะเดียวกันในซอฟต์แวร์สร้างอัตโนมัติบางอย่างเช่นในภาษาการเขียนโปรแกรมดังนั้นฉันคิดว่ามันยากที่จะเขียนจัดการได้ ไฟล์ Makefiles หรือ SConscript สำหรับโครงการใด ๆ ที่มีความซับซ้อนปานกลาง ไม่มีใครมีคำแนะนำในการเขียนไฟล์อินพุตที่สามารถจัดการได้สำหรับซอฟต์แวร์สร้างอัตโนมัติ คำแนะนำผู้ไม่เชื่อเรื่องพระเจ้าของซอฟต์แวร์จะดีที่สุด แต่แม้คำแนะนำเกี่ยวกับเครื่องมือสร้างอัตโนมัติเฉพาะจะมีประโยชน์โดยเฉพาะอย่างยิ่ง Make หรือ SCons เนื่องจากนั่นคือสิ่งที่ฉันใช้สำหรับโครงการ แก้ไข:ตามที่Thorbjørnชี้ให้เห็นฉันควรเพิ่มบริบทและตัวอย่างการใช้งาน ฉันจบปริญญาเอกสาขาวิศวกรรมเคมีและฉันค้นคว้าทางวิทยาศาสตร์การคำนวณ (ฉันเป็นนักเขียนมืออาชีพที่ SciComp.SE สำหรับผู้ที่เข้าชม) โดยทั่วไปโครงการของฉันเกี่ยวข้องกับภาษาที่รวบรวม (C, C ++, Fortran) ที่มีการยกระดับสูง, สคริปต์ภาษา (Python) , Perl) สำหรับการสร้างต้นแบบและบางครั้งภาษาเฉพาะโดเมนสำหรับการสร้างต้นแบบหรือวัตถุประสงค์ทางเทคนิค ฉันได้เพิ่มสองตัวอย่างด้านล่างโดยประมาณในช่วง …

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

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

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

5
มีประโยชน์กับ mini-refactor code โดยหวังว่าจะปรับปรุงคุณภาพหรือเป็นเพียง“ การเคลื่อนย้ายโค้ดไปรอบ ๆ ” โดยไม่มีประโยชน์มาก?
ตัวอย่าง ฉันเจอรหัสเสาหินที่ทำ "ทุกอย่าง" ในที่เดียว - โหลดข้อมูลจากฐานข้อมูลแสดงมาร์กอัพ HTML ทำหน้าที่เป็นเราเตอร์ / คอนโทรลเลอร์ / การกระทำ ฉันเริ่มใช้การย้ายรหัสฐานข้อมูล SRP ไปยังไฟล์ของตัวเองโดยให้การตั้งชื่อที่ดีขึ้นสำหรับสิ่งต่าง ๆ และมันก็ดูดี แต่แล้วฉันก็เริ่มสงสัยว่าทำไมฉันถึงทำแบบนี้ ทำไมต้องรีแฟคเตอร์ จุดประสงค์คืออะไร? มันไร้ประโยชน์หรือเปล่า? ประโยชน์คืออะไร โปรดทราบว่าฉันส่วนใหญ่ออกจากไฟล์เสาหินตามที่เป็นอยู่ แต่ refactored เฉพาะส่วนเล็ก ๆ ที่เกี่ยวข้องกับพื้นที่ที่ฉันต้องทำงานบางอย่าง รหัสเดิม: เพื่อเป็นตัวอย่างที่เป็นรูปธรรมฉันได้พบข้อมูลโค้ดนี้ - มันโหลดข้อมูลจำเพาะของผลิตภัณฑ์โดยใช้รหัสผลิตภัณฑ์ที่รู้จักหรือโดยรหัสรุ่นที่ผู้ใช้เลือก: if ($verid) $sql1 = "SELECT * FROM product_spec WHERE id = " . clean_input($verid); else $sql1 = "SELECT …

4
ศัพท์เทคนิคที่ใช้แทนการฉีดแบบพึ่งพา?
นี่เป็นศัพท์เฉพาะ (การเขียนเชิงเทคนิค) มากกว่าคำถามทางเทคนิคอย่างแท้จริง ฉันกำลังพยายามเขียนข้อเสนอการปรับโครงสร้างใหม่ (และให้สิทธิ์ตัวเอง) โดยมีศูนย์กลางที่การขยายการฉีดที่ต้องพึ่งพาในแอปพลิเคชันของเรา ในขณะที่เราใช้Springในการเรียกถั่วอัตโนมัติยังคงมีกรณีที่ยกตัวอย่างถั่วที่ใช้MyClass obj = new MyClass(...)ซึ่งสามารถฉีดได้ทั้งหมด ฉันต้องการทำให้ข้อเสนอของฉันใช้ระบบการตั้งชื่อที่สง่างามและอ้างอิงถึงรูปแบบการออกแบบตรงข้ามกับ DI ด้วยคำที่เหมาะสม คำว่า "คับคัปปลิ้ง" เป็นคำที่เพียงพอหรือไม่ที่ตรงกันข้ามกับ DI?

7
หลังจากเขียนโค้ดแล้วทำไมฉันถึงรู้สึกว่า“ ฉันจะเขียนได้ดีขึ้น” หลังจากผ่านไประยะหนึ่ง [ปิด]
ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้มีแนวโน้มที่จะเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน8 ปีที่ผ่านมา ฉันทำงานเกี่ยวกับโครงการอดิเรกใน C ++ เป็นเวลานานกว่า 2 ปีแล้ว เมื่อใดก็ตามที่ฉันเขียนโมดูล / ฟังก์ชั่นฉันรหัสมันด้วยความคิดมากมาย ตอนนี้ดูปัญหา do { --> write the code in module 'X' and test it --> ... forget for sometime ... --> revisit the same piece of code (due to some requirement) --> feel that …

7
หลักการการเปลี่ยนโครงสร้างและเปิด / ปิด
ฉันเพิ่งอ่านเว็บไซต์เกี่ยวกับการพัฒนาโค้ดที่สะอาด (ฉันไม่ได้ใส่ลิงค์ไว้ที่นี่เพราะไม่ใช่ภาษาอังกฤษ) หนึ่งในหลักการที่โฆษณาโดยไซต์นี้คือหลักการเปิดปิด : ส่วนประกอบซอฟต์แวร์แต่ละรายการควรเปิดเพื่อขยายและปิดเพื่อการปรับเปลี่ยน เช่นเมื่อเรานำไปใช้และทดสอบคลาสเราควรแก้ไขเพื่อแก้ไขข้อบกพร่องหรือเพื่อเพิ่มฟังก์ชั่นใหม่ (เช่นวิธีการใหม่ที่ไม่มีผลต่อคลาสที่มีอยู่) ไม่ควรเปลี่ยนฟังก์ชันการทำงานและการใช้งานที่มีอยู่ ผมปกติใช้หลักการนี้ด้วยการกำหนดอินเตอร์เฟซและระดับการดำเนินงานที่สอดคล้องกันI Aเมื่อชั้นเรียนAมีเสถียรภาพ (ดำเนินการและทดสอบ) ปกติแล้วฉันจะไม่แก้ไขมากเกินไป (อาจไม่เลย) เช่น หากข้อกำหนดใหม่มาถึง (เช่นประสิทธิภาพหรือการใช้อินเทอร์เฟซใหม่ทั้งหมด) ที่ต้องมีการเปลี่ยนแปลงโค้ดอย่างมากฉันจะเขียนการใช้งานใหม่Bและใช้ต่อไปAตราบเท่าที่Bยังไม่ครบกำหนด เมื่อBครบกำหนดแล้วสิ่งที่จำเป็นต้องมีก็คือเปลี่ยนวิธีการIสร้างอินสแตนซ์ หากความต้องการใหม่แนะนำการเปลี่ยนแปลงอินเตอร์เฟซเป็นอย่างดีฉันกำหนดอินเตอร์เฟซใหม่และการดำเนินงานใหม่I' A'ดังนั้นI, Aมีแช่แข็งและยังคงอยู่ในการดำเนินการสำหรับระบบการผลิตเป็นเวลานานเป็นI'และA'มีไม่เพียงพอที่มั่นคงเพื่อแทนที่พวกเขา ดังนั้นในมุมมองของการสังเกตเหล่านี้ฉันรู้สึกประหลาดใจเล็กน้อยที่หน้าเว็บนั้นแนะนำให้ใช้การปรับโครงสร้างที่ซับซ้อน "... เนื่องจากไม่สามารถเขียนโค้ดโดยตรงในรูปแบบสุดท้าย" ไม่มีความขัดแย้ง / ความขัดแย้งระหว่างการบังคับใช้หลักการเปิด / ปิดและแนะนำให้ใช้การปรับโครงสร้างที่ซับซ้อนเป็นวิธีปฏิบัติที่ดีที่สุดหรือไม่? หรือความคิดในที่นี้คือเราสามารถใช้ refactorings ที่ซับซ้อนในระหว่างการพัฒนาคลาสAแต่เมื่อคลาสนั้นได้รับการทดสอบสำเร็จแล้วควรจะถูกแช่แข็งหรือไม่

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

4
การจัดการงาน "ที่เกี่ยวข้อง" ภายในรายการงานที่คล่องตัวเพียงรายการเดียว
ฉันอยู่ในทีมโปรเจคที่มี 4 devs ฉันรวมอยู่ด้วย เราได้มีการพูดคุยกันอย่างยาวนานเกี่ยวกับวิธีจัดการกับงานพิเศษที่เกิดขึ้นในรายการงานชิ้นเดียว งานพิเศษนี้มักจะเป็นสิ่งที่เกี่ยวข้องกับงานเล็กน้อย แต่ไม่จำเป็นเสมอไปที่จะบรรลุเป้าหมายของรายการ (อาจเป็นความเห็น) ตัวอย่างรวมถึง แต่ไม่ จำกัด เฉพาะ: refactoring ของรหัสการเปลี่ยนแปลงโดยรายการงาน refactoring code ที่อยู่ใกล้เคียงรหัสที่ถูกเปลี่ยนแปลงโดยรายการ ออกแบบพื้นที่โค้ดขนาดใหญ่รอบตั๋วอีกครั้ง ตัวอย่างเช่นหากรายการที่คุณเปลี่ยนฟังก์ชั่นเดียวคุณรู้ว่าตอนนี้ทั้งคลาสสามารถทำซ้ำได้เพื่อให้รองรับการเปลี่ยนแปลงนี้ได้ดียิ่งขึ้น ปรับปรุง UI บนแบบฟอร์มที่คุณเพิ่งแก้ไข เมื่องานพิเศษนี้เล็กเราไม่รังเกียจ ปัญหาคือเมื่องานพิเศษนี้ทำให้ส่วนขยายของรายการเกินกว่าการประมาณจุดคุณลักษณะดั้งเดิม บางครั้งรายการ 5 คะแนนจะใช้เวลา 13 คะแนน ในกรณีหนึ่งเรามีรายการ 13 จุดที่ในการหวนกลับอาจมี 80 คะแนนหรือมากกว่า ในการสนทนาของเรามีสองทางเลือกสำหรับวิธีจัดการกับปัญหานี้ เราสามารถรับงานพิเศษในรายการงานเดียวกันและเขียนออกเป็นการประเมินที่ผิดพลาด อาร์กิวเมนต์สำหรับสิ่งนี้ได้รวม: เราวางแผนสำหรับ "การเติมเต็ม" ในตอนท้ายของการวิ่งเพื่ออธิบายสิ่งนี้ ปล่อยให้รหัสอยู่ในรูปที่ดีกว่าที่คุณพบเสมอ อย่าเช็คอินงานครึ่งทาง หากเราออกจากการปรับโครงสร้างใหม่ในภายหลังมันยากที่จะกำหนดเวลาและอาจไม่เสร็จสิ้น คุณอยู่ใน "บริบท" ทางจิตใจที่ดีที่สุดในการจัดการงานนี้ในขณะนี้เนื่องจากคุณอยู่ลึกเข้าไปในรหัสแล้ว ดีกว่าที่จะนำมันออกไปให้พ้นทางและมีประสิทธิภาพมากกว่าที่จะเสียบริบทนั้นไปเมื่อคุณกลับมาในภายหลัง เราวาดเส้นสำหรับไอเท็มงานปัจจุบันและบอกว่างานพิเศษเข้าสู่ตั๋วแยกต่างหาก ข้อโต้แย้งรวมถึง: การมีตั๋วแยกต่างหากช่วยให้การประเมินใหม่ดังนั้นเราจึงไม่โกหกตัวเองเกี่ยวกับจำนวนของสิ่งที่เป็นจริงหรือต้องยอมรับว่าการประเมินทั้งหมดของเรานั้นแย่มาก …

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

2
การแพร่กระจายรหัสที่มีความคิดเห็น refactoring เป็นความคิดที่ดี?
ฉันกำลังทำงานในโครงการ "สปาเก็ตตี้โค้ด" และในขณะที่ฉันกำลังแก้ไขข้อบกพร่องและใช้งานคุณสมบัติใหม่ ๆ ฉันก็ทำการปรับโครงสร้างใหม่เพื่อให้สามารถทดสอบโค้ดหน่วยได้ รหัสมักจะถูกรวมเข้าด้วยกันอย่างแน่นหนาหรือซับซ้อนซึ่งการแก้ไขข้อบกพร่องเล็ก ๆ จะส่งผลให้มีการเขียนคลาสใหม่จำนวนมาก ดังนั้นฉันจึงตัดสินใจวาดเส้นหนึ่งในรหัสที่ฉันหยุด refactoring เพื่อให้ชัดเจนฉันวางความคิดเห็นในรหัสอธิบายสถานการณ์เช่น: class RefactoredClass { private SingletonClass xyz; // I know SingletonClass is a Singleton, so I would not need to pass it here. // However, I would like to get rid of it in the future, so it is passed …

5
การทำซ้ำรหัสกับวิธีที่รับผิดชอบหลายอย่าง
ฉันพยายามปฏิบัติตาม Single Responsibility Principle (SRP) และไม่ใช้ Code ซ้ำ อย่างไรก็ตามมักจะมีสถานที่ที่มีการทำซ้ำรหัสที่ไม่มีอะไรมากไปกว่าบล็อคโค้ดของการเรียกใช้ที่สามารถต้านทานการแตกออกเป็นอย่างน้อยแปลความหมายเต็มวิธีการชื่อ: DoAction1(); DoAction2(); if (value) DoAction3(); DoAction4(); เป็นวิธีที่ดีที่สุดในการแยกรหัสดังกล่าวเป็นวิธีการและวิธีการตั้งชื่อมันได้อย่างไร

5
ทำไมชั้นเรียนของฉันถึงแย่กว่าลำดับชั้นของหนังสือ (OOP เริ่มต้น)
ฉันอ่านPHP วัตถุรูปแบบและการปฏิบัติ ผู้เขียนพยายามสร้างแบบจำลองบทเรียนในวิทยาลัย เป้าหมายคือการส่งออกประเภทบทเรียน (การบรรยายหรือการสัมมนา) และค่าใช้จ่ายสำหรับบทเรียนขึ้นอยู่กับว่าเป็นบทเรียนราคาชั่วโมงหรือคงที่ ดังนั้นผลลัพธ์ควรเป็น Lesson charge 20. Charge type: hourly rate. Lesson type: seminar. Lesson charge 30. Charge type: fixed rate. Lesson type: lecture. เมื่ออินพุตเป็นดังนี้: $lessons[] = new Lesson('hourly rate', 4, 'seminar'); $lessons[] = new Lesson('fixed rate', null, 'lecture'); ฉันเขียนสิ่งนี้: class Lesson { private $chargeType; private $duration; …

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