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

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

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

สารบัญ:

1. ลักษณะของรหัสการผลิตคุณภาพสูง
2. การตั้งชื่อการพาความร้อน
   2.1. ตัวแปร
   2.2. ฟังก์ชั่น
   2.3. ชั้นเรียน
3. การใช้พื้นที่สีขาวที่ดี
   3.1. การ เยื้อง
   3.2. ความยาวบรรทัดสูงสุด
   3.3. เส้นเปล่า
4. ความคิดเห็น & เอกสาร
   ประกอบ 4.1. ความคิดเห็นในบรรทัด
   4.2. เอกสารคำสอน
   4.3. เอกสาร
5. อ้างอิง

1. ลักษณะของรหัสการผลิตคุณภาพสูง

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

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

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

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

เขียนโค้ด Python ที่มีประสิทธิภาพสำหรับนักวิทยาศาสตร์ข้อมูล: การกำหนดและการวัดประสิทธิภาพของโค้ด

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

• Focused Code:แต่ละฟังก์ชัน คลาส หรือโมดูลควรทำอย่างใดอย่างหนึ่งและทำได้ดี
• โค้ดอ่านง่าย: Grady Booch ผู้เขียน Object-Oriented Analysis and Design with Applications: โค้ดสะอาดอ่านเหมือนร้อยแก้วที่เขียนอย่างดี
• แก้จุดบกพร่องโค้ดได้ง่าย: โค้ดสะอาดสามารถดีบั๊กและแก้ไขข้อผิดพลาดได้ง่าย เนื่องจากอ่านและปฏิบัติตามได้ง่าย
• บำรุงรักษาง่าย:นั่นคือสามารถอ่านและปรับปรุงโดยนักพัฒนารายอื่นได้อย่างง่ายดาย

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

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

2. การตั้งชื่อการพา

การตั้งชื่อเป็นหนึ่งในลักษณะที่มีประโยชน์และสำคัญที่สุดในการเขียนโค้ดที่สะอาด เมื่อตั้งชื่อตัวแปร ฟังก์ชัน คลาส ฯลฯ คุณควรใช้ชื่อที่สื่อความหมายและชัดเจน และนี่หมายความว่าเราจะชอบชื่อที่สื่อความหมายยาว ๆ มากกว่าชื่อสั้น ๆ ที่กำกวม

ก่อนอื่นมาเริ่มกันที่หลักการตั้งชื่อ PEP 8:

• ชื่อคลาสควรเป็น CamelCase ( MyClass)
• ชื่อตัวแปรควรเป็น snake_case และตัวพิมพ์เล็กทั้งหมด ( first_name)
• ชื่อฟังก์ชันควรเป็น snake_case และตัวพิมพ์เล็กทั้งหมด ( quick_sort())
• ค่าคงที่ควรเป็น snake_case และตัวพิมพ์ใหญ่ทั้งหมด ( PI = 3.14159)
• โมดูลควรมีชื่อสั้น ๆ ชื่อ snake_case และตัวพิมพ์เล็กทั้งหมด ( numpy)
• อัญประกาศเดี่ยวและอัญประกาศคู่ถือว่าเหมือนกัน (เพียงเลือกหนึ่งรายการและสอดคล้องกัน)

2.1. ตัวแปร

1. ใช้ชื่อที่สื่อความหมายยาวและอ่านง่าย:สิ่งนี้สำคัญมากในการตั้งชื่อให้ง่ายและสื่อความหมาย และสามารถเข้าใจได้ด้วยตัวเอง สิ่งนี้จะทำให้จำเป็นต้องเขียนความคิดเห็น:

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

6. อย่าใช้เลขวิเศษ เลขวิเศษคือตัวเลขที่มีความหมายพิเศษแบบฮาร์ดโค้ดที่ปรากฏในโค้ดแต่ไม่มีความหมายหรือคำอธิบายใดๆ โดยปกติแล้ว ตัวเลขเหล่านี้จะปรากฏเป็นตัวอักษรในตำแหน่งมากกว่าหนึ่งตำแหน่งในโค้ดของเรา

2.2. ฟังก์ชั่น

7. ชื่อยาว != ชื่อที่สื่อความหมาย — คุณควรสื่อความหมายแต่ต้องมีข้อมูลที่เกี่ยวข้องเท่านั้น สำหรับ เช่น ชื่อฟังก์ชันที่ดีจะอธิบายถึงสิ่งที่พวกเขาทำได้ดี โดยไม่รวมรายละเอียดเกี่ยวกับการนำไปใช้งานหรือการใช้งานเฉพาะเจาะจงสูง

8. สอดคล้องกับรูปแบบการตั้งชื่อฟังก์ชันของคุณ:ดังที่เห็นได้จากตัวแปรด้านบน ให้ยึดตามหลักการตั้งชื่อเมื่อตั้งชื่อฟังก์ชัน การใช้หลักการตั้งชื่อที่แตกต่างกันจะทำให้นักพัฒนาและเพื่อนร่วมงานคนอื่นๆ สับสนได้

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

2.3. ชั้นเรียน

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

3. การใช้พื้นที่สีขาวที่ดี

3.1. การเยื้อง

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

3.2. ความยาวบรรทัดสูงสุด

พยายามจำกัดบรรทัดของคุณให้อยู่ที่ประมาณ 79 อักขระ ซึ่งเป็นแนวทางที่กำหนดใน คู่มือ สไตล์PEP 8 ในโปรแกรมแก้ไขข้อความที่ดีหลายๆ ตัว จะมีการตั้งค่าให้แสดงบรรทัดย่อยที่ระบุตำแหน่งที่จำกัด 79 อักขระ

3.3. เส้นเปล่า

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

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

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

4.1. ความคิดเห็นในบรรทัด

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

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

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

ต่อไปนี้เป็นเคล็ดลับในการเขียนความคิดเห็นที่ดี:

1. อย่าแสดงความคิดเห็นเกี่ยวกับโค้ดที่ไม่ดี เขียนใหม่

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

2. อย่าเพิ่มความคิดเห็นเมื่อไม่จำเป็นต้องทำ

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

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

3. อย่าแสดงความคิดเห็นรหัสที่ล้าสมัย

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

4.2. เอกสาร

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

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

4.3. เอกสาร

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

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

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

5. การอ้างอิง

1. 10 รูปแบบที่ต้องรู้สำหรับการเขียนโค้ดสะอาดด้วย Python
2. ล้างรหัสใน Python

ขอบคุณที่อ่าน! หากคุณชอบบทความนี้ อย่าลืมตบมือ (มากถึง 50 ครั้ง!) และเชื่อมต่อกับฉันบนLinkedInและติดตามฉันบนสื่อเพื่อติดตามข่าวสารล่าสุดเกี่ยวกับบทความใหม่ของฉัน

เพิ่มระดับการเข้ารหัส

ขอบคุณที่เป็นส่วนหนึ่งของชุมชนของเรา! ก่อนที่คุณจะไป:

• ปรบมือให้กับเรื่องราวและติดตามผู้เขียน
• ดูเนื้อหาเพิ่มเติมในสิ่งพิมพ์ Level Up Coding
• ติดตามเรา: Twitter | LinkedIn | จดหมายข่าว