ระบุและประเมินฟังก์ชันขนาดใหญ่โดยใช้โหมด Ask ของ GitHub Copilot

เสร็จสมบูรณ์เมื่อ

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

โหมดถามของ GitHub Copilot มีประโยชน์เมื่อต้องรับมือกับฟังก์ชันขนาดใหญ่ที่ซับซ้อนและเข้าใจยาก ด้วยการถามคําถามที่ตรงเป้าหมาย คุณสามารถแบ่งฟังก์ชันขนาดใหญ่ออกเป็นส่วนที่จัดการได้

กรณีการใช้งานทั่วไปสําหรับโหมดถามของ GitHub Copilot

โหมดถามของ GitHub Copilot ถูกรวมเข้ากับ Visual Studio Code ผ่านส่วนขยาย GitHub Copilot Chat คุณสามารถเริ่มการสนทนาในโหมดถามได้โดยเปิดแผงแชทและพิมพ์คําถามของคุณเป็นภาษาธรรมชาติ ต่อไปนี้เป็นกรณีการใช้งานทั่วไปสําหรับโหมดถาม

• อธิบาย/สรุปรหัส: สร้างรายละเอียดภาษาธรรมชาติของสิ่งที่โค้ดทํา คุณสามารถขอให้ GitHub Copilot สรุปฐานรหัสทั้งหมดหรือคลาส เมธอด หรือบล็อกโค้ดใดๆ
• ระบุส่วนตรรกะ: มักจะส่งกลับรายการลําดับเลขของงานหรือขั้นตอนที่โค้ดดําเนินการ
• เน้นปัญหา: อาจชี้ให้เห็นถึงความซ้ําซ้อนหรือความซับซ้อน
• ตอบคําถามเฉพาะ: "ลูปนี้ทําอะไรได้บ้าง" หรือ "เหตุใดจึงจําเป็นต้องใช้พารามิเตอร์เหล่านี้"
• แนะนําแนวทางการปรับโครงสร้างใหม่: "คุณสามารถแยกขั้นตอนเหล่านี้ออกเป็นฟังก์ชันแยกต่างหากได้..."

ระบุและประเมินฟังก์ชันขนาดใหญ่โดยใช้โหมด Ask ของ GitHub Copilot

มีหลายสถานการณ์ที่โหมดถามสามารถช่วยในการระบุและวิเคราะห์ฟังก์ชันขนาดใหญ่ได้:

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

นี่คือกระบวนการระดับสูงที่ใช้ GitHub Copilot เพื่อระบุและวิเคราะห์ฟังก์ชันขนาดใหญ่:

1. ระบุฟังก์ชันขนาดใหญ่ที่มีปัญหา: ใช้โหมดถามเพื่อระบุฟังก์ชันที่เกินเกณฑ์ที่ระบุ

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

3. ประเมินฟังก์ชันขนาดใหญ่ที่เฉพาะเจาะจง: ใช้โหมดถามเพื่อวิเคราะห์ฟังก์ชันโดยละเอียด

   1. ถามคําถาม โดยใช้ข้อความแจ้งภาษาธรรมชาติ เช่น:

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

   2. ตรวจสอบการตอบกลับของ GitHub Copilot ในแผงแชท:

      1. ใช้ความเข้าใจของคุณเกี่ยวกับฐานรหัสและกฎทางธุรกิจที่เกี่ยวข้อง ใช้ความรู้ของคุณเองเพื่อตรวจสอบการวิเคราะห์ของ GitHub Copilot

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

   3. ถามการติดตามผล:

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

   4. วางแผนการปรับโครงสร้างใหม่ของคุณ:

      1. ใช้ข้อมูลเชิงลึกเพื่อร่างกลยุทธ์การปรับโครงสร้างใหม่

      2. ตัดสินใจว่าจะแยกส่วนใดออกเป็นฟังก์ชันหรือคลาสแยกต่างหาก

เคล็ดลับในการใช้โหมดถามอย่างมีประสิทธิภาพ

เพื่อให้ได้ประโยชน์สูงสุดจากโหมด Ask ของ GitHub Copilot ให้พิจารณาเคล็ดลับต่อไปนี้:

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

Note

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

Summary

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