Copilot to Refractor Code ஐ எவ்வாறு பயன்படுத்துவது

AI தயாரிப்புகள் நவீன காலத்தில் மென்பொருள் மேம்பாடு அல்லது குறியீட்டு முறையில் புரட்சியை ஏற்படுத்தியுள்ளன. AI ஐப் பயன்படுத்தி, நிரலாக்கக் குறியீடுகளை தானாகவே உருவாக்கி, அவற்றைச் சரிசெய்து மேம்படுத்தலாம் குறியீடு மறுசீரமைப்பு . இந்த கட்டுரையில், மறுசீரமைப்பு செயல்முறையை நாங்கள் ஆராய்ந்து, உங்களால் எப்படி முடியும் என்பதைப் பார்க்கிறோம் Copilot to Refractor Code ஐப் பயன்படுத்தவும் .

குறியீடு மறுசீரமைப்பு என்றால் என்ன?

மென்பொருள் அல்லது பயன்பாட்டு மேம்பாட்டில், கோட் ரீஃபாக்டரிங் என்பது நிரல் மூலக் குறியீட்டை அதன் அசல் செயல்பாட்டைப் பராமரிக்கும் போது மறுகட்டமைப்பது அல்லது மறுசீரமைப்பதைக் குறிக்கிறது. இந்த செயல்முறை மென்பொருளின் கட்டமைப்பையும் வடிவமைப்பையும் மேம்படுத்துவதையும் சிக்கலைக் குறைப்பதையும் நோக்கமாகக் கொண்டுள்ளது. குறியீடு மறுசீரமைப்பில் AI இன் ஒருங்கிணைப்பு, மென்பொருள் செயல்திறன் சிக்கல்களை உடனடியாகக் கண்டறியவும், ஒட்டுமொத்த செயல்திறனை மேம்படுத்த சிக்கலான வழிமுறைகளை எளிதாக்கவும் எங்களுக்கு உதவியது.

குறியீடுகளை மறுசீரமைப்பதில் கோபிலட் எவ்வாறு உதவ முடியும்?

இது குறியீட்டின் ஒரு குறிப்பிட்ட பகுதியைப் பகுப்பாய்வு செய்து, சிக்கலைக் குறைக்க அதன் கட்டமைப்பை தூய்மையான மற்றும் பயனர் நட்பு வடிவத்திற்கு மேம்படுத்துவதற்கான பரிந்துரைகளை வழங்க முடியும். வழங்கப்பட்ட பரிந்துரைகள் பின்வருவனவற்றை அடிப்படையாகக் கொண்டவை:

• ஏற்கனவே உள்ள குறியீட்டில் உள்ள சிக்கல்களை அடையாளம் காணவும்: நகல் குறியீடுகள், பயன்படுத்தப்படாத அல்லது தெளிவற்ற மாறிகள் போன்றவற்றைச் சுட்டிக்காட்டுவதன் மூலம் மறுவடிவமைக்கப்பட வேண்டிய பிரிவுகள் அல்லது பகுதிகளை முன்னிலைப்படுத்த Copilot முழு குறியீடு கோப்பையும் ஸ்கேன் செய்கிறது.
• பயனுள்ள விருப்பங்களை பரிந்துரைக்கவும்: குறியீட்டை மறுசீரமைக்கும் போது, ​​கோபிலட் ஏற்கனவே உள்ள குறியீட்டை பகுப்பாய்வு செய்து, அதே முடிவுகளைத் தரக்கூடிய திறமையான மாற்றுகளை பரிந்துரைக்கிறது, ஆனால் குறியீட்டை சுத்தமாக்குகிறது. இந்த பரிந்துரைகளில் மாறிகள், முறைகள் மற்றும் தரவு கட்டமைப்புகளுக்கு பெயரிடுவதற்கான திறமையான மொழிப் பயன்பாடு அடங்கும்.
• பராமரிக்கக்கூடிய குறியீட்டை உறுதிப்படுத்தவும்: நிகழ்நேர பின்னூட்டம் எந்தப் பிழைகளையும் சேர்ப்பதைத் தவிர்க்க உதவுகிறது. பரிந்துரைகள் பொதுவாக நிரலாக்கக் கொள்கைகளின் சிறந்த நடைமுறைகளை அடிப்படையாகக் கொண்டவை, அவை சரியான குறியீட்டு கட்டமைப்பைப் பராமரிக்க உதவுகின்றன, மற்றவர்களுக்கு எளிதாகப் புரிந்துகொள்வது மற்றும் தேவைப்பட்டால் அதை மாற்றுவது.

Copilot to Refractor Code ஐ எவ்வாறு பயன்படுத்துவது

மறுசீரமைப்பிற்கு Copilot ஐப் பயன்படுத்த, நாம் தொடங்கலாம் GitHub Copilot ஐ நிறுவுகிறது சம்பந்தப்பட்ட மொழிக்கான நீட்டிப்பு (VS குறியீடு, பைதான் போன்றவை). எடுத்துக்காட்டாக, பைத்தானில் எழுதப்பட்ட மூலக் குறியீட்டை மறுகட்டமைக்க விரும்பினால், கோபிலட் செருகுநிரலை நாம் நிறுவலாம்:

மேற்பரப்புடன் தொலைக்காட்சியை இணைக்கிறது

• ஒருங்கிணைந்த மேம்பாட்டு சூழல் அல்லது IDE (ஜாவாஸ்கிரிப்ட் அல்லது பைதான்) இல் அமைப்புகள் விருப்பத்தைத் திறக்க கிளிக் செய்யவும்.
• இடதுபுறத்தில் உள்ள செருகுநிரல் விருப்பத்தை கிளிக் செய்யவும்.
• கிளிக் செய்யவும் சந்தை விருப்பம் மற்றும் தேடல் கிட்ஹப் கோபிலட் சொருகு.
• கண்டுபிடிக்கப்பட்டதும், கிளிக் செய்யவும் நிறுவு சொருகி நிறுவ.

• நிறுவல் முடிந்ததும் மறுதொடக்கம் செய்ய IDE கேட்கும். மறுதொடக்கம் செய்த பிறகு, IDE ஐ திறந்து கிளிக் செய்யவும் கருவிகள் -> GitHub Copilot -> GitHub இல் உள்நுழைக.

• வெற்றிகரமாக உள்நுழைந்த பிறகு, Copilot பயன்பாட்டிற்கு தயாராக இருக்கும்.
• Copilot ஐப் பயன்படுத்த, குறியீட்டை எழுதும் போது கீழே உள்ள குறுக்குவழிகளைப் பயன்படுத்தலாம்

தொடர்புடையது: GitHub இலிருந்து பதிவிறக்கம் செய்யப்பட்ட குறியீட்டைப் பார்ப்பது எப்படி

எடுத்துக்காட்டு 1: ஒரு சிக்கலான குறியீட்டை எளிமைப்படுத்த

Copilot இன் ரீஃபாக்டரிங் அம்சத்தைப் பயன்படுத்தி சிக்கலான குறியீட்டை எவ்வாறு எளிமைப்படுத்தலாம் என்பதை விளக்குவதற்கு கீழே உள்ள குறியீட்டு துணுக்கைப் பார்ப்போம். இங்கே, புரிந்துகொள்வதற்கான ஒரு பெரிய திட்டத்தின் ஒரு பகுதியை மட்டுமே நாங்கள் கருத்தில் கொள்கிறோம்:

மறுசீரமைப்புக்கு முன்

       public void processOrder(Order order) {
         // ... further codes
         if (order.isReadyForProcessing()) {
             // process the order
         }
         //... further codes
     }

கோபிலட்டுடன் மறுசீரமைத்த பிறகு

       public void processOrder(Order order) {
         // ...further codes
         processReadyOrder(order);
         // ...further codes
     }

      private void processReadyOrder(Order order) {
         if (order.isReadyForProcessing()) {
             // process the order
         }
     }

மேலே உள்ள எடுத்துக்காட்டில், குறியீடுகளின் முதல் தொகுப்பு ( மறுசீரமைப்பதற்கு முன்) ஒரு செயல்பாடு அல்லது பெயரிடப்பட்ட முறையைக் கொண்டுள்ளது செயல்முறை ஒழுங்கு, இது ஒரு குறிப்பிட்ட வரிசையைச் செயலாக்குவதற்கான படிகளைச் செய்கிறது. ஆர்டரைச் செயலாக்குவதற்கு முன், நிபந்தனைக்குட்பட்ட IF அறிக்கையானது, ஆர்டர் செயலாக்கத்திற்குத் தயாராக உள்ளதா அல்லது பயன்படுத்தவில்லையா என்பதைச் சரிபார்க்கும் என்றால் (order.isReadyForProcessing()) செயல்பாடு. இந்தக் குறியீடுகளின் தொகுப்பில், முதன்மைச் செயல்பாட்டிற்குள் செயலாக்க தர்க்கம் சேர்க்கப்பட்டுள்ளது, இது குறைவான மட்டுப்படுத்துகிறது.

பின்வரும் குறியீடு துணுக்கில், எங்களிடம் உள்ளது செயல்முறை ஒழுங்கு ஆர்டரை செயலாக்குவதற்கான செயல்பாடு. எவ்வாறாயினும், தயாராக உள்ள ஆர்டரைச் செயலாக்குவதற்கும் செயலாக்குவதற்கும் ஆர்டர் தயாரா என்பதைச் சரிபார்ப்பதற்கான தர்க்கம் பெயரிடப்பட்ட ஒரு தனிச் செயல்பாட்டிற்கு நகர்த்தப்பட்டது. processReadyOrder. குறியீடிற்கான தெளிவு மற்றும் மாடுலாரிட்டியை வழங்க, ஒவ்வொரு முறையையும் தனிமைப்படுத்த இது உதவுகிறது.

எடுத்துக்காட்டு 2: மாறி மறுபெயரிடுதல்

மறுசீரமைப்புக்கு முன்

வாசகர் சாளரங்கள் 8

      def calculate_area(l, w):
return l * w

கோபிலட்டுடன் மறுசீரமைத்த பிறகு

     def calculate_area(length, width):
 return length * width

மறுசீரமைப்பிற்குப் பிறகு, 'l' மற்றும் 'w' மாறிகள் நீளம் மற்றும் அகலத்துடன் மாற்றப்பட்டன, இது மறுபெயரிடுவதன் மூலம் குறியீட்டின் தெளிவை மறுசீரமைப்பின் இன்றியமையாத அம்சமாகச் சேர்த்தது.

கோபிலட் குறியீட்டை மறுகட்டமைக்க எங்களுக்கு உதவ முடியும் என்றாலும், தவறான பரிந்துரைகள், மிகைப்படுத்தல் மற்றும் காலாவதியான குறியீடுகளைப் பிரதிபலிப்பது போன்ற பல வரம்புகளைக் கொண்டுள்ளது. அதன் பரிந்துரைகளை நீங்கள் பெற்றவுடன், நீங்கள் அனைத்து கையேடு சரிபார்ப்புகளையும் மற்றும் சரிபார்க்கவும் சரியான அறிவுறுத்தல்களைப் பயன்படுத்தவும்.

GitHub Copilot என்ன தரவுகளில் பயிற்சி பெற்றுள்ளது?

கிட்ஹப் கோபிலட், கிட்ஹப்பில் உள்ள பொதுக் களஞ்சியங்களில் உள்ள குறியீடு உட்பட, பொதுவில் கிடைக்கும் மூலங்களிலிருந்து இயற்கை மொழி உரை மற்றும் மூலக் குறியீடு குறித்து பயிற்சியளிக்கப்பட்டது. இது கிட்ஹப், ஓபன்ஏஐ மற்றும் மைக்ரோசாப்ட் உருவாக்கிய ஜெனரேட்டிவ் AI மாடல்களால் இயக்கப்படுகிறது.

Copilot க்கான இணக்கமான நிரலாக்க மொழிகள் யாவை?

Github Copilot பல்வேறு மொழிகளை ஆதரிக்கிறது ஆனால் குறிப்பாக JavaScript, TypeScript, Ruby, Python, Go, C++, மற்றும் C# உடன் நன்றாக வேலை செய்கிறது.

• மேலும்