บอกลาจาวาสคริปต์ที่ไม่ดี

Nov 29 2022

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

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

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

1. ใช้ var แทน let และ const

ถึงเวลาบอกลาการใช้ var

คุณควรใช้เพียง let และ const ด้วยเหตุผลเหล่านี้:

● ขอบเขตชัดเจนขึ้น (ระหว่างวงเล็บปีกกา)

● มันไม่ได้สร้างวัตถุส่วนกลาง

● จะแจ้งข้อผิดพลาดหากคุณประกาศอีกครั้ง

เว้นแต่คุณจะใช้เบราว์เซอร์รุ่นเก่า เช่น IE11 อันเป็นที่รัก คุณควรเลิกใช้ var เพื่อประโยชน์สูงสุดของคุณ Let และ Const จะเป็นเพื่อนที่ดีที่สุดของคุณในอนาคต

2. การใช้ความคิดเห็นเพื่ออธิบายโค้ด

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

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

● หลีกเลี่ยงความซ้ำซ้อนในความคิดเห็นของคุณ อย่าเขียนว่าคุณทำอะไร ให้เขียนว่าทำไมคุณถึงทำอย่างนั้น

● ตัวแปร/ฟังก์ชัน/ชื่อคลาสที่สื่อความหมายได้ดีกว่าความคิดเห็นเชิงพรรณนา

● สรุปให้ได้มากที่สุด อย่าเขียนย่อหน้าถ้าไม่จำเป็นจริงๆ

● พยายามใช้ภาษาและรูปแบบความคิดเห็นเดียวกันเสมอ

● เมื่อเวลาผ่านไป ความคิดเห็นมักจะไม่รักษา (แก้ไข) รหัสคือ

3. ใช้ == แทน ===

สิ่งแรกที่ต้องเข้าใจก็คือ แม้ว่าพวกมันจะดูคล้ายกันมาก แต่พวกมันทำสิ่งที่ต่างกัน: ตัวแรกเรียกว่าตัวดำเนินการความเสมอภาคปกติ (==) และตัวที่สองเรียกว่าตัวดำเนินการความเท่าเทียมกันแบบเข้มงวด (===)

ตัวดำเนินการความเสมอภาคปกติ (==) จะตรวจสอบเฉพาะว่าตัวถูกดำเนินการคล้ายกันหรือไม่ ซึ่งอาจทำให้เกิดความประหลาดใจที่ไม่พึงประสงค์

ตัวดำเนินการความเท่าเทียมกันอย่างเคร่งครัด (===) ตรวจสอบเสมอว่าตัวถูกดำเนินการมีประเภทและค่าต่างกัน และเหมือนกันทุกประการ

4. ลืมใช้การผูกมัดเพิ่มเติม

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

สิ่งนี้ช่วยให้เราหลีกเลี่ยงข้อผิดพลาดเมื่อพยายามเข้าถึงพร็อพเพอร์ตี้ที่ไม่มีอยู่ ตัวอย่างเช่น สมมติว่าเรามีวัตถุโปเกมอนที่มีข้อมูลของโปเกมอนนั้น

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

5. ไม่ใช้สายวิเศษและเลขวิเศษ

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

6. จัดการข้อผิดพลาดในการเรียก API อย่างไม่เหมาะสม

เราควรจัดการข้อผิดพลาดด้วยการลอง/จับใน async/await ของเราเสมอ

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

7. การใช้วัตถุเป็นพารามิเตอร์เดียว

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

ประการแรก มันทำให้โค้ดของเราอ่านง่ายขึ้นโดยรู้ตั้งแต่ต้นว่าฟังก์ชันของเราต้องการพารามิเตอร์ใด

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

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

8. ลืมพลังของตัวย่อ

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

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

บทสรุป

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

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

หากคุณมีข้อเสนอแนะใด ๆ โปรดแบ่งปันในส่วนความคิดเห็น เราสามารถเติบโตไปด้วยกันได้