ฉันต้องการพูดอย่างรวดเร็วเกี่ยวกับแนวคิดเรื่องโค้ดสะอาด ซึ่งเป็นสิ่งที่เราเคยพูดถึงมาก่อน
และนี่เป็นตัวอย่างที่ดีในการทำบางอย่าง เช่น ฟังก์ชัน
ตัวอย่างเช่น สมมติว่าเรามีฟังก์ชันที่อาจตรวจสอบว่าตัวเลขเป็นเลขคู่หรือคี่
เอาเป็นว่า.
เป็นเลขคี่หรือคู่เป็นฟังก์ชันที่รับค่าตัวเลข
และเราจะได้ยินว่า เราจะตรวจสอบอย่างไร?
เราสามารถใช้โมดูโลโอเปอเรเตอร์ได้
ฉันสามารถพูดได้ว่าถ้า
โมดูโลที่สอง ซึ่งจำได้ ให้ส่วนที่เหลือแก่เรา
และถ้าเป็นเลขคู่ เศษที่เหลือจะเป็นศูนย์เสมอ
นี่จะบอกเราว่ามันเป็นเลขคู่หรือไม่
แล้วถ้าเป็นเลขคู่.
แล้วฉันอยากให้คุณกลับมา
จริง.
และถ้ามันไม่ใช่จำนวนคู่ สมมุติว่ามึน
ถึง.
ไม่เท่ากัน.
ศูนย์.
ดังนั้นหากเป็นเลขคี่, ก็จะเหลือเศษเสมอ.
ในกรณีนั้นเราจะคืนค่าเท็จ
งั้นลองเปลี่ยนฟังก์ชันนี้ให้ละเอียดกว่านี้ดีกว่า มันจะคืนค่าเป็นจริง
ถ้ามันยังเป็นเท็จ
ถ้ามันไม่เท่ากัน
ดังนั้นในนี้ ถ้าฉันทำเป็นเลขคู่และให้ 50 และรัน โอ้ ฉันได้รับข้อผิดพลาดเพราะฉันต้องทำให้แน่ใจว่าฉันใช้คำสั่ง
L if ที่นี่
เราต้องพิมพ์ที่นี่
เลยมาพิมพ์กัน
และคลิกเรียกใช้
ฉันจะเป็นจริงถ้าฉันทำ 51 และคลิกเรียกใช้
ฉันได้รับเท็จ
ไม่เป็นไร.
ดูเหมือนว่าจะใช้งานได้ แต่เราจะล้างรหัสนี้ได้อย่างไร
นี่คือสิ่งที่
เรามีวิธีที่จะทำให้เรื่องนี้กระชับขึ้นอีกนิด
ตัวอย่างเช่น หากเราตรวจสอบเฉพาะค่าเป็นคู่ เราไม่จำเป็นต้องตรวจสอบอีกครั้งเพราะ
หากจำนวนโมดูโลที่สองไม่เท่ากับศูนย์ นั่นคือถ้าตัวเลขหารด้วยสองไม่มีเศษของศูนย์เสมอไป
เรารู้อยู่เสมอว่ามันดีไม่เสมอกัน
ดังนั้นเราจึงไม่ต้องการคำกล่าวนี้ด้วยซ้ำ
เราสามารถพูดอย่างอื่นได้
ถูกต้อง.
เพื่อที่ว่าถ้าฉันเรียกใช้สิ่งนี้
นี้ยังคงทำงาน
เสียใจ.
ดังนั้นเราจึงล้างรหัสของเราเล็กน้อย
แต่นี่คือสิ่งที่
อีกสิ่งหนึ่งที่เราสามารถทำได้คือเราทราบว่าฟังก์ชันจะคืนค่าส่วนเกินโดยอัตโนมัติ
ดังนั้นเราจึงไม่ต้องการแม้แต่คำสั่ง
ฉันสามารถพูดได้ว่ากลับมาที่นี่เพราะมันจะไปถึงบรรทัดที่ห้าเท่านั้นหากคำสั่งไม่ถูกต้อง
ถ้ามันยังไม่ดี ผมจะข้ามบรรทัดที่สี่และไปที่บรรทัดที่ห้า เพื่อว่าถ้าผมรันสิ่งนี้
มันยังคงใช้งานได้ ตกลงไหม?
แต่เราสามารถทำให้สิ่งนี้สะอาดยิ่งขึ้นใช่ไหม?
เพราะตอนนี้เราเพิ่งกลับ
จริงหรือเท็จ?
และโดยปกติถ้าคุณมีสิ่งนี้โดยส่งคืน true false โดยตรง มักจะมีวิธีที่ดีกว่า
นั่นคือการใช้นิพจน์ที่ประเมินเป็นบูลีน
สิ่งที่เราทำได้จริง ๆ ก็แค่พูดว่า เฮ้ เอาทั้งหมดนี่ออกไปแล้วฉันต้องการให้คุณกลับมา
แบบนี้.
และถ้าเราดำเนินการนี้
ยังมีงานอยู่นะ
และถ้าฉันทำ 50
สิ่งนี้ยังคงใช้ได้เพราะสิ่งที่เรากำลังพูดในที่นี้คือ ฉันต้องการให้คุณคืนค่าใดๆ ก็ตามที่เป็นค่านี้
และนี่คืออัตราการแสดงออกที่จะประเมินค่าจริงเท็จโดยตรง
ดังนั้นเราจึงได้ผลลัพธ์ที่เท่าเดิม แต่ดูว่ามันสะอาดขึ้นแค่ไหน
นั่นเป็นเพียงรหัสที่ดีและเรียบง่าย
และในฐานะนักพัฒนา ฉันสามารถเข้ามาที่นี่และเห็นได้ทันทีไหม?
ไม่เป็นไร.
แม้เป็นเพียงการดำเนินการนี้และคืนค่าจริงหรือเท็จ?
นี่เป็นวิธีที่ดีในการคิดเกี่ยวกับโค้ดที่สะอาด
คุณจะล้างรหัสของคุณได้อย่างไร?
และโปรดทราบว่าไม่มีวิธีแก้ปัญหาที่สมบูรณ์แบบ
คุณสามารถล้างโค้ดได้เสมอ แต่การคิดแบบนี้จะช่วยให้คุณพัฒนาวิธีที่โปรแกรมเมอร์ขั้นสูงคิดได้จริงๆ
เจอกันใหม่ตอนหน้าค่ะ
ลาก่อน.