கோலாங் ஜெனரிக்ஸ் எடுத்துக்காட்டுகள்

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

எடுத்துக்காட்டு 1: கோலாங் ஜெனரிக் செயல்பாட்டைப் பயன்படுத்துதல்

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

முந்தைய குறியீட்டின் தொடக்கத்தில், வரியானது 'fmt' தொகுப்பை இறக்குமதி செய்கிறது, இது கன்சோலில் வெளியீட்டை அச்சிடுவது உட்பட வடிவமைக்கப்பட்ட I/O க்கான செயல்பாடுகளை வழங்குகிறது. பின்னர், 'சுற்றளவு' என்ற பெயரிடப்பட்ட ஒரு பொதுவான செயல்பாட்டை வரையறுக்கிறோம், இது ஒரு பொதுவான வகை 'r' இன் அளவுரு ஆரம் எடுக்கும், இது 'int' அல்லது 'float32' ஆக இருக்கலாம். செயல்பாட்டின் உள்ளே, இது '3' இன் நிலையான மதிப்பால் ஆரம் பெருக்குவதன் மூலம் சுற்றளவைக் கணக்கிடுகிறது, பின்னர் அதை '2' ஆல் பெருக்குகிறது. இறுதியாக, இது 'fmt.Println' ஐப் பயன்படுத்தி கணக்கிடப்பட்ட சுற்றளவை அச்சிடுகிறது.

அடுத்து, இரண்டு மாறிகள், r1 மற்றும் r2 ஆகியவை முறையே 7 மற்றும் 7.5 மதிப்புகளுடன் அறிவிக்கப்பட்டு ஒதுக்கப்படும் முக்கிய செயல்பாடு எங்களிடம் உள்ளது. அதன் பிறகு, 'சுற்றளவு' செயல்பாடு இரண்டு முறை செயல்படுத்தப்படுகிறது, r1 மற்றும் r2 ஐ வாதங்களாகக் கடந்து செல்கிறது.

வெளியீடு பின்வரும் வட்டங்களின் சுற்றளவை அச்சிடுவதன் மூலம் கணக்கீட்டைக் காட்டுகிறது:

எடுத்துக்காட்டு 2:  Golang பொதுவான இடைமுகத்தைப் பயன்படுத்துதல்

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

முந்தைய மூலக் குறியீட்டில், பணியாளரின் வயதுக்கான சாத்தியமான வகைகளைக் குறிப்பிடும் 'EmpAge' என்ற இடைமுகத்தை நாங்கள் வரையறுத்துள்ளோம். இடைமுகத்தில் int64, int32, float32 மற்றும் float64 வகைகள் உள்ளன. இந்த இடைமுகம் 'பொதுவான' செயல்பாட்டை இந்த வகைகளில் ஏதேனும் ஒன்றை ஒரு வாதமாக ஏற்றுக்கொள்ள அனுமதிக்கிறது. அதன் பிறகு, நாங்கள் புதிய ஜெனரிக் ஃபங்க் என்ற பொதுவான செயல்பாட்டைப் பயன்படுத்துகிறோம், இது எம்பேஜ் இடைமுகத்தை திருப்திப்படுத்தும் எந்த வகையாக இருந்தாலும் பொதுவான வகை வயதின் emp_Age அளவுருவை எடுக்கும். செயல்பாட்டின் உள்ளே, இது emp_Age ஐ ஒரு எண்ணாக மாற்றுகிறது மற்றும் காட்டப்பட்டுள்ளபடி அதை 1 ஆல் அதிகரிக்கிறது.

அடுத்து, நாம் இரண்டு மாறிகள், Age1 மற்றும் Age2 ஆகியவற்றை அறிவித்து, முக்கிய செயல்பாட்டில் முறையே 24 மற்றும் 25.5 மதிப்புகளை ஒதுக்குகிறோம். அதன்பிறகு, வயது1 மற்றும் வயது2 இரண்டு முறை செயல்படுத்தப்படும் புதிய ஜெனரிக்ஃபங்க் செயல்பாட்டிற்கு அளவுருக்களாக அனுப்பப்படுகின்றன. இதன் மூலம், வயது 1 ஆல் உயர்த்தப்பட்டு புதுப்பிக்கப்பட்ட மதிப்புகளை உருவாக்குகிறது.

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

எடுத்துக்காட்டு 3: கோலாங் பொதுவான தரவுக் கட்டமைப்பைப் பயன்படுத்துதல்

மேலும், Go generics ஆனது அடுக்குகள், வரிசைகள் மற்றும் இணைக்கப்பட்ட பட்டியல்கள் போன்ற பொதுவான தரவு கட்டமைப்புகளை உருவாக்கும் திறனையும் வழங்குகிறது. பின்வருவனவற்றில் பொதுவான அடுக்கை செயல்படுத்துவதைக் கவனியுங்கள்:

முந்தைய குறியீட்டில், 'ஸ்டாக்' என்ற தலைப்பில் ஒரு பொதுவான வகை வரையறுக்கப்பட்டுள்ளது, இது அடுக்கைக் குறிக்கிறது. 'T' ஒதுக்கிடமானது எந்த வகையின் கூறுகளையும் வைத்திருக்க அடுக்கை அனுமதிக்கிறது. 'ஸ்டேக்' வகை 'டி' வகையின் உறுப்புகளின் ஒரு துண்டுகளாக செயல்படுத்தப்படுகிறது. இங்கே, 'ஸ்டாக்' வகைக்கு இரண்டு செயல்பாடுகள் பயன்படுத்தப்படுகின்றன: 'புஷ்' மற்றும் 'பாப்.' புஷ்() செயல்பாடு ஸ்டேக்கில் உறுப்புகளைச் சேர்ப்பதற்கு பொறுப்பாகும். இது 'T' வகையின் ஒரு வாத உருப்படியை எடுத்து, append() செயல்பாட்டைப் பயன்படுத்தி அடிப்படை ஸ்லைஸில் சேர்க்கிறது.

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

அடுத்து, இந்த குறியீட்டின் முக்கிய செயல்பாட்டிற்குள் Stack[int] தொடரியல் பயன்படுத்தி முழு எண்களின் புதிய அடுக்கு உருவாக்கப்படுகிறது. அதன் பிறகு, 'புஷ்' முறையானது 1, 2 மற்றும் 3 ஆகிய முழு எண்களை அடுக்கில் சேர்க்க மூன்று முறை அழைக்கப்படுகிறது. இருப்பினும், 'பாப்' முறையானது அடுக்கிலிருந்து உறுப்புகளை மீட்டெடுக்கவும் அச்சிடவும் மூன்று முறை அழைக்கப்படுகிறது.

பின்வரும் வெளியீடு, தலைகீழ் வரிசையில் அடுக்கிலிருந்து உறுப்புகள் அகற்றப்பட்டதைக் குறிக்கிறது:

எடுத்துக்காட்டு 4: கோலாங் பொதுவான கட்டுப்பாடுகளைப் பயன்படுத்துதல்

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

முந்தைய மூலக் குறியீட்டில், 'சம்' முறையுடன் எண்கள் இடைமுகத்தை வரையறுக்கிறோம். பின்னர், 'FloatValue' மற்றும் 'IntegerValue' ஆகிய இரண்டு தனிப்பயன் வகைகளை உருவாக்குகிறோம், அவை அந்தந்த 'தொகை' முறைகளை வழங்குவதன் மூலம் எண்கள் இடைமுகத்தை செயல்படுத்துகின்றன. genericSum செயல்பாடு இப்போது எண்கள் இடைமுகத்தை திருப்திப்படுத்தும் எந்த வகை துண்டுகளையும் ஏற்க முடியும். செயல்பாட்டின் உள்ளே, நாம் உறுப்புகளின் மீது மீண்டும் கூறுகிறோம் மற்றும் கூட்டுத்தொகையைக் கணக்கிட 'சம்' முறையை அழைக்கிறோம். இறுதியாக, முக்கிய செயல்பாட்டில், FloatValue மற்றும் IntegerValue துண்டுகளை உருவாக்கி, அவற்றை genericSum() செயல்பாட்டிற்கு அனுப்புகிறோம், இது ஒவ்வொரு ஸ்லைஸிலும் உள்ள உறுப்புகளின் கூட்டுத்தொகையை சரியாகக் கணக்கிடுகிறது.

எதிர்பார்க்கப்படும் வெளியீடு இப்போது பின்வரும் திரையில் தெரியும்:

முடிவுரை

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