ฉันจะป้องกันการทำซ้ำรหัสโดยไม่รู้จักได้อย่างไร

ฉันทำงานบนฐานรหัสที่ค่อนข้างใหญ่ หลายร้อยคลาส, ไฟล์ที่แตกต่างกันมากมาย, ฟังก์ชั่นมากมายใช้เวลามากกว่า 15 นาทีในการดึงสำเนาใหม่และอื่น ๆ

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

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

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

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

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

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

ขั้นตอนที่ 1เริ่มเขียนการทดสอบในรหัสดั้งเดิม (ควรใช้กรอบการทดสอบ)

ขั้นตอนที่ 2เขียนซ้ำ / refactor รหัสที่ซ้ำกันโดยใช้สิ่งที่คุณได้เรียนรู้จากการทดสอบ

คุณสามารถใช้เครื่องมือวิเคราะห์แบบคงที่เพื่อตรวจสอบรหัสที่ซ้ำกันและสำหรับ C # มีเครื่องมือมากมายที่สามารถทำสิ่งนี้เพื่อคุณ:

• StackOverflow - เครื่องมืออะไรในการค้นหารหัสที่ซ้ำกันในโครงการ C #

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

• แคตตาล็อก Refactor เพื่อรูปแบบ

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

1. ระบุจุดเปลี่ยน
2. ค้นหาคะแนนการทดสอบ
3. ทำลายการพึ่งพา
4. ทดสอบการเขียน
5. ทำการเปลี่ยนแปลงและ refactor

หนังสือเล่มนี้เป็นหนังสือที่อ่านได้ดีหากคุณกำลังเผชิญกับการพัฒนาด้านสีน้ำตาลเช่นรหัสดั้งเดิมที่จำเป็นต้องเปลี่ยน

ในกรณีนี้

ในกรณีของ OP ฉันนึกภาพได้ว่าโค้ดที่ไม่สามารถทดสอบได้เกิดจากหม้อน้ำผึ้งสำหรับ "วิธีการและเทคนิคยูทิลิตี้" ที่มีหลายรูปแบบ:

• วิธีการคงที่
• การใช้ทรัพยากรคงที่
• ชั้นเรียนเดี่ยว
• ค่าเวทย์มนตร์

รับทราบว่าไม่มีอะไรผิดปกติกับสิ่งเหล่านี้ แต่ในทางกลับกันพวกเขามักจะรักษาและเปลี่ยนแปลงได้ยาก วิธีการส่วนขยายใน. NET เป็นวิธีการคงที่ แต่ก็ค่อนข้างง่ายต่อการทดสอบ

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

เนื่องจาก OP เป็นรหัสใหม่ที่มีสิ่งอื่น ๆ ให้ทำก่อนที่คุณจะทำอะไร:

• ใช้เวลาในการเรียนรู้จาก codebase เช่น break "ทุกอย่าง" ทดสอบ "ทุกอย่าง" แล้วย้อนกลับ
• ถามใครบางคนจากทีมเพื่อตรวจสอบรหัสของคุณก่อนที่จะกระทำ ;-)

โชคดี!

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

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

ผู้แต่งหนังสือเล่มนี้ Johannes Sametinger อธิบายชุดของอุปสรรคในการใช้รหัสซ้ำซึ่งบางแนวคิดมีเทคนิคบางอย่าง ตัวอย่างเช่น

แนวคิดและเทคนิค

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

ปัญหาทางเทคนิคขั้นพื้นฐานอื่น ๆ ได้แก่

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

ตามที่ผู้เขียนกล่าวว่าระดับความสามารถในการนำกลับมาใช้ที่แตกต่างกันนั้นขึ้นอยู่กับวุฒิภาวะขององค์กร

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

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

มีวิธีแก้ปัญหาที่เป็นไปได้ 2 แบบ:

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

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

ฉันเองไม่คิดว่าการป้องกันเป็นไปได้ ยิ่งคุณพยายามมากเท่าไหร่ก็ยิ่งมีปัญหาในการค้นหาคุณลักษณะที่มีอยู่แล้ว

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

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

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

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

มีวิธีแก้ปัญหาสำหรับเรื่องนี้และเรียกว่า Generics ซึ่งได้รับการแนะนำใน Java 6 มันเทียบเท่ากับ C ++ เรียกว่าแม่แบบ รหัสของคลาสที่แน่นอนยังไม่เป็นที่รู้จักใน Class Generic โปรดตรวจสอบ Java Generics และคุณจะพบเอกสารจำนวนมาก

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

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

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

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

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

ฉันมีสถานการณ์ที่คล้ายกันซึ่งในชั้นเรียนทั่วไปในที่สุดแทนที่บางสิ่งบางอย่างเช่น 6 หรือ 7 ชั้นเรียนที่เหมือนกันเกือบทั้งหมดที่เกือบเหมือนกันเกือบทั้งหมด แต่ได้รับการคัดลอกและวางโดยโปรแกรมเมอร์ต่าง ๆ ในช่วงเวลาหนึ่ง

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

หวังว่าสิ่งนี้จะช่วยและโชคดี

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

ถ้าพูดให้คุณเลือกใช้:

A) ไลบรารีรูปภาพขนาดเล็กที่มีเสถียรภาพ (ไม่เปลี่ยนแปลง) และผ่านการทดสอบอย่างดีซึ่งซ้ำกันสองสามบรรทัดของรหัสทางคณิตศาสตร์เล็กน้อยสำหรับคณิตศาสตร์แบบเวกเตอร์เช่นผลิตภัณฑ์ dot และ lerps และ clamps แต่แยกออกจากส่วนอื่นและสร้างในส่วนของ วินาที.

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

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

แต่ยังมีการแต่งงานกันและความมั่นคงที่จะคิดและการทำสำเนาเล็กน้อยที่นี่และสามารถทำหน้าที่เป็นกลไก decoupling ซึ่งยังเพิ่มความมั่นคง (ธรรมชาติไม่เปลี่ยนแปลง) ของแพคเกจ

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

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

อาจมีเหตุผลสามประการ:

1. ชุดรูปแบบรอบงานนี้จะเหมือนกันสำหรับโมดูลทั้งสอง ในกรณีนี้การทำสำเนารหัสไม่ดีและควรชำระบัญชี มันจะฉลาดในการสร้างคลาสหรือโมดูลเพื่อสนับสนุนธีมนี้และใช้วิธีการในโมดูลทั้งสอง

2. งานเป็นไปตามทฤษฎีในแง่ของโครงการของคุณ ตัวอย่างเช่นมันมาจากฟิสิกส์หรือคณิตศาสตร์เป็นต้นงานมีอยู่อย่างอิสระในโครงการของคุณ ในกรณีนี้การทำสำเนารหัสไม่ดีและควรชำระบัญชีด้วย ฉันจะสร้างคลาสพิเศษสำหรับฟังก์ชั่นดังกล่าว และใช้ฟังก์ชั่นดังกล่าวในโมดูลใด ๆ ที่คุณต้องการ

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

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

ดังนั้นพยายามรักษาความสะอาดเมื่อจำเป็นจริงๆและอย่ากลัวการทำซ้ำหากไม่จำเป็น