எடுத்துக்காட்டு 1: கோலாங் அடிப்படை வகை வார்ப்பு
கோவில் நேரடி மற்றும் அடிப்படை வார்ப்பு உதாரணத்துடன் தொடங்குவோம், ஏனென்றால் மாறியின் வகையை எங்கும் மாற்றுவதற்கு டைப்காஸ்டிங் தேவைப்படுகிறது.
தொகுப்பு முக்கியஇறக்குமதி (
'fmt'
)
செயல்பாடு முக்கிய () {
இருந்தது எக்ஸ் முழு எண்ணாக = 31
மற்றும் := மிதவை64 ( எக்ஸ் )
fmt . Println ( மற்றும் )
}
இங்கே, 'int' வகையின் 'x' என்ற பெயரிடப்பட்ட மாறியை அறிவிப்பதன் மூலம் முக்கிய செயல்பாட்டைத் தொடங்கி, அதை 31 மதிப்புடன் ஒதுக்குவோம். பின்னர், 'y' மாறி ':=' என்ற சுருக்கெழுத்து ஒதுக்கீட்டு ஆபரேட்டரைப் பயன்படுத்தி அறிவிக்கப்படும். 'x' ஐ 'float64' ஆக மாற்றுவதன் விளைவாக, வலது பக்கத்தில் உள்ள வெளிப்பாட்டிலிருந்து 'y' வகை தானாகவே தீர்மானிக்கப்படுகிறது. எனவே, இந்த நிரலில், 'x' இன் மதிப்பு 'float64' ஆக மாற்றப்பட்டு 'y' க்கு ஒதுக்கப்படுகிறது.
Go இல் உள்ள அடிப்படை வார்ப்புகளிலிருந்து பெறப்பட்ட முடிவுகள் பின்வருமாறு காட்டப்படும்:
எடுத்துக்காட்டு 2: கோலாங் மறைமுக வகை வார்ப்பு
வெவ்வேறு வகைகளுக்கு இடையே உள்ளுறை வகை வார்ப்பு அனுமதிக்கப்படாது. வலுவான தட்டச்சு செய்வதை Go செயல்படுத்துகிறது, அதாவது வெளிப்படையான மாற்றமின்றி ஒரு வகையின் மதிப்பை மற்றொரு வகையாக நேரடியாக ஒதுக்கவோ பயன்படுத்தவோ முடியாது. பின்வருவனவற்றில், Go மூலம் விதிவிலக்கை உருவாக்கும் மறைமுகமான வார்ப்பைச் செய்ய முயற்சிக்கிறோம்:
தொகுப்பு முக்கிய
இறக்குமதி 'fmt'
செயல்பாடு முக்கிய () {
இருந்தது முழு முழு எண்ணாக = 9 . 08
fmt . Printf ( 'முழு எண் %g' , முழு )
}
முக்கிய() செயல்பாட்டுடன் தொடங்கும் குறியீடு இங்கே உள்ளது, அங்கு 'முழு' மாறி 'int' வகையுடன் அறிவிக்கப்படும். 'முழு எண்' மாறிக்கு ஒதுக்கப்பட்ட மதிப்பு 9.08 ஆகும், இது ஒரு மிதக்கும்-புள்ளி எண்ணாகும். ஒரு முழு எண் மாறிக்கு நேரடியாக மிதக்கும் புள்ளி மதிப்பை ஒதுக்க முயற்சிப்பதால், இது ஒரு வகை பொருந்தாத பிழையை விளைவிக்கிறது. பின்னர், '%g' வடிவக் குறிப்பானைப் பயன்படுத்தி 'முழு' மாறியின் மதிப்பை அச்சிட, 'fmt' தொகுப்பிலிருந்து 'printf' செயல்பாட்டைப் பயன்படுத்துகிறோம்.
எதிர்பார்த்தபடி, கோலாங்கில் மறைமுகமான நடிப்பு ஏற்கத்தக்கதல்ல. முந்தைய மறைமுக வகை வார்ப்பு பின்வரும் பிழையை உருவாக்குகிறது:
எடுத்துக்காட்டு 3: கோலாங் வெளிப்படையான வகை வார்ப்பு
வெளிப்படையான வகை மாற்றமானது, ஒரு நோக்கத்தை வெளிப்படையாகக் கூறும்போது, இணக்கமான வகைகளுக்கு இடையே மதிப்புகளைப் பாதுகாப்பாக மாற்றுவதற்கு உதவுகிறது. இது வகை மாற்றத்தை நாங்கள் அறிந்திருப்பதை உறுதிசெய்கிறது மற்றும் தற்செயலான வகை பிழைகளைத் தடுக்க உதவுகிறது. பின்வரும் வெளிப்படையான நடிப்பைக் கவனியுங்கள்:
தொகுப்பு முக்கியஇறக்குமதி 'fmt'
செயல்பாடு முக்கிய () {
இருந்தது மிதவை வால் மிதவை32 = 6 . 75
இருந்தது intVal முழு எண்ணாக = முழு எண்ணாக ( மிதவை வால் )
fmt . Printf ( 'ஃப்ளோட் மதிப்பு %g \n ' , மிதவை வால் )
fmt . Printf ( 'முழு மதிப்பு %d' , intVal )
}
இங்கே, 'floatVal' மாறியானது 'float32' வகையுடன் உருவாக்கப்பட்டது, மேலும் அதற்கு '6.75' மதிப்பு ஒதுக்கப்படுகிறது. பின்னர், 'intVal' மாறியானது 'int' வகையுடன் அறிவிக்கப்படுகிறது. floatVal இன் மதிப்பை intVal க்கு ஒதுக்க, வகை மாற்றம் பயன்படுத்தப்படுகிறது. floatVal ஐ முழு எண் மதிப்பாக மாற்ற, 'int' செயல்பாடு floatVal ஐ உள்ளீடாகப் பயன்படுத்தப்படுகிறது. அதன் பிறகு, 'fmt.Printf('Float Value is %g\n', floatVal)' மிதக்கும் புள்ளி மதிப்புகளை அச்சிடுவதற்கு ஏற்ற %g வடிவமைப்பு குறிப்பான் மூலம் floatVal இன் மதிப்பை அச்சிடுகிறது. 'fmt.Printf('முழு மதிப்பு %d', intVal)' குறியீட்டு வரியானது, முழு எண் மதிப்புகளை அச்சிடுவதற்கு ஏற்ற %d வடிவமைப்பு விவரக்குறிப்பைப் பயன்படுத்தி intVal இன் மதிப்பை அச்சிடுகிறது.
பின்வரும் வெளியீடு அதை அனுப்பிய பின் floatVal மற்றும் intVal இரண்டிற்கும் மதிப்புகளை உருவாக்குகிறது:
எடுத்துக்காட்டு 4: சராசரியைப் பெற கோலாங் வகை வார்ப்பு
அடுத்து, கொடுக்கப்பட்ட மதிப்புகளிலிருந்து சராசரி எண்ணைப் பெற வார்ப்பைச் செய்கிறோம். பின்வருவனவற்றில் வழங்கப்பட்டுள்ள மூலக் குறியீட்டின் மூலம் செல்லலாம்:
தொகுப்பு முக்கியஇறக்குமதி 'fmt'
செயல்பாடு முக்கிய () {
இருந்தது மொத்தம் முழு எண்ணாக = 900
இருந்தது என்னுடைய இலக்கம் முழு எண்ணாக = இருபது
இருந்தது சராசரி மிதவை32
சராசரி = மிதவை32 ( மொத்தம் ) / மிதவை32 ( என்னுடைய இலக்கம் )
fmt . Printf ( 'சராசரி = %f \n ' , சராசரி )
}
இங்கே, நாம் ஆரம்பத்தில் மூன்று மாறிகளை அறிவிக்கிறோம். 'மொத்தம்' என்பது 900 இன் மதிப்புடன் துவக்கப்படும் ஒரு முழு எண் மாறியாகும். 'MyNumber' என்பது 20 இன் மதிப்புடன் துவக்கப்படும் ஒரு முழு எண் மாறியாகும். கணக்கிடப்பட்ட சராசரியானது float32 'சராசரி' மாறியில் சேமிக்கப்படும். கணக்கீட்டைச் செய்ய சராசரி சூத்திரம் கொடுக்கப்படுகிறது. பிரிவு ஒரு மிதக்கும் புள்ளி பிரிவாக செய்யப்படுவதை உறுதிசெய்ய, வகை மாற்றத்தைப் பயன்படுத்தி 'மொத்தம்' மற்றும் 'MyNumber' மதிப்புகள் float32 ஆக மாற்றப்படுகின்றன. கணக்கிடப்பட்ட சராசரியானது 'சராசரி' மாறிக்கு ஒதுக்கப்படுகிறது. இறுதியாக, 'printf' செயல்பாட்டில் பயன்படுத்தப்படும் '%f\n' வடிவமைப்பு சரமானது ஒரு மிதவை மதிப்பை அச்சிட வேண்டும், அதைத் தொடர்ந்து ஒரு புதிய வரி எழுத்தைக் குறிப்பிடுகிறது.
முந்தைய குறியீட்டில் உள்ள வார்ப்பு வகையைக் குறிப்பிட்ட பிறகு சராசரியாக விளைந்த மதிப்பு பெறப்படுகிறது:
எடுத்துக்காட்டு 5: Golang Int மற்றும் String Type Casting
கூடுதலாக, Go ஆனது Int மற்றும் String வகைகளுக்கு இடையே வார்ப்புகளை வழங்குகிறது. strconv தொகுப்பின் செயல்பாட்டைப் பயன்படுத்தி நாம் இதைச் செய்யலாம்.
தொகுப்பு முக்கியஇறக்குமதி (
'fmt'
'strconv'
)
செயல்பாடு முக்கிய () {
இருந்தது str லேசான கயிறு = '1999'
உள்ளே , _ := strconv . டிரெய்லர் ( கள் )
fmt . Println ( உள்ளே )
இருந்தது முழு முழு எண்ணாக = 1999
toStr := strconv . மூழ்கினார் ( முழு )
fmt . Println ( toStr )
}
இரண்டு மாறிகளின் அறிவிப்புடன் தொடங்கும் குறியீடு இங்கே. 'str' என்பது '1999' மதிப்புடன் துவக்கப்படும் ஒரு சரம் மாறியாகும் மற்றும் 'முழு எண்' என்பது '1999' மதிப்புடன் துவக்கப்படும் ஒரு முழு எண் மாறியாகும். அதன் பிறகு, 'strconv.Atoi()' செயல்பாடு 'str' சரத்தை முழு எண் மதிப்பாக மாற்ற பயன்படுகிறது. 'v' இன் திரும்பிய மதிப்பு மாற்றப்பட்ட முழு எண்ணைக் குறிக்கிறது, மேலும் Atoi() மூலம் வழங்கப்படும் சாத்தியமான பிழையைப் புறக்கணிக்க வெற்று '_' அடையாளங்காட்டி பயன்படுத்தப்படுகிறது.
அடுத்து, முழு எண்ணை சர மதிப்பாக மாற்ற strconv.Itoa() செயல்பாடு பயன்படுத்தப்படுகிறது. திரும்பிய மதிப்பு 'toStr' மாற்றப்பட்ட சரத்தை குறிக்கிறது.
வெளியீடு “1999” சரத்திலிருந்து முழு எண்ணாகவும், “1999” இன் அசல் மதிப்பை உருவாக்கும் சரமாகவும் மாற்றுவதைக் காட்டுகிறது:
எடுத்துக்காட்டு 6: சரம் மற்றும் பைட்டுகளுக்கு இடையே கோலாங் வகை வார்ப்பு
மேலும், கோவில் நடிப்பதை சரம் மற்றும் பைட் வகைகளிலும் செய்யலாம். பின்வரும் குறியீடுகள் சரங்கள் மற்றும் பைட் துண்டுகளுக்கு இடையிலான மாற்றத்தை நிரூபிக்கின்றன:
தொகுப்பு முக்கியஇறக்குமதி (
'fmt'
)
செயல்பாடு முக்கிய () {
இருந்தது மர்மம் லேசான கயிறு = 'ஏய் அங்கே'
இருந்தது b1 [] பைட் = [] பைட் ( myStr )
fmt . Println ( b1 )
toString := லேசான கயிறு ( b1 )
fmt . Println ( toString )
}
இங்கே, மாறிகள் முதலில் 'myStr' மற்றும் 'b1' என அறிவிக்கப்படுகின்றன, அவை சில மதிப்புகளுடன் துவக்கப்படுகின்றன. பின்னர், []byte(myStr) வெளிப்பாடு வகை மாற்றத்தைப் பயன்படுத்தி “myStr” சரத்தை பைட் ஸ்லைஸாக மாற்றுகிறது. இதன் விளைவாக வரும் பைட் ஸ்லைஸை “b1” மாறிக்கு ஒதுக்குகிறது. அதன் பிறகு, 'ஸ்ட்ரிங்(பி1)' வெளிப்பாடு வகை மாற்றத்தைப் பயன்படுத்தி பைட் ஸ்லைஸ் b1 ஐ மீண்டும் சரமாக மாற்றுகிறது. இதன் விளைவாக வரும் சரத்தை 'toString' மாறிக்கு ஒதுக்குகிறது.
வெளியீடு 'ஹே தேர்' சரத்திற்கும் அதன் தொடர்புடைய பைட் ஸ்லைஸ் பிரதிநிதித்துவத்திற்கும் இடையே உள்ள மாற்றத்தை பின்வருவனவற்றில் காட்டுகிறது:
எடுத்துக்காட்டு 7: சதுர வேரைப் பெற கோலாங் வகை வார்ப்பு
இப்போது, ஸ்கொயர் ரூட் முடிவுகளைக் கண்டறிய Go இல் வார்ப்பு செய்கிறோம். குறியீடு பின்வருமாறு வைக்கப்பட்டுள்ளது:
தொகுப்பு முக்கியஇறக்குமதி (
'fmt'
'கணிதம்'
)
செயல்பாடு முக்கிய () {
இருந்தது n முழு எண்ணாக = 177
இருந்தது SqrtN மிதவை64
SqrtN = கணிதம் . சதுர ( மிதவை64 ( n ))
fmt . Printf ( '%d இன் சதுர மூலமானது %.2f ஆகும் \n ' , n , SqrtN )
}
இங்கே, “n” மாறி ஒரு முழு எண்ணாக அறிவிக்கப்பட்டு “144” இன் மதிப்பை ஒதுக்குகிறது. 'SqrtN' மாறியானது float64 ஆக அறிவிக்கப்பட்டு, 'n' இன் கணக்கிடப்பட்ட வர்க்க மூலத்தை சேமிக்கிறது. பின்னர், 'n' இன் வர்க்க மூலத்தைக் கணக்கிட, math.Sqrt() செயல்பாடு பயன்படுத்தப்படுகிறது. math.Sqrt() ஒரு float64 வாதத்தை எதிர்பார்க்கிறது, மேலும் “n” இன் மதிப்பு float64(n) ஐப் பயன்படுத்தி float64 ஆக மாற்றப்படுகிறது. அதன் பிறகு, '%d இன் ஸ்கொயர் ரூட் %.2f\n' வடிவமைப்பு சரத்தை 'printf' செயல்பாட்டில் அழைக்கிறது, இது ஒரு முழு எண் மதிப்பையும் (%d) மற்றும் மிதக்கும் புள்ளி மதிப்பையும் (%.2f) குறிப்பிடுகிறது. '%.2f' இல் உள்ள '.2' துல்லிய குறிப்பான், வர்க்க மூலமானது இரண்டு தசம இடங்களுடன் அச்சிடப்பட்டிருப்பதை உறுதி செய்கிறது.
கொடுக்கப்பட்ட மதிப்பின் வர்க்க மூலத்தைக் குறிக்கும் பின்வரும் வெளியீடு பெறப்பட்டது:
முடிவுரை
Go இல் நடிப்பது அனைத்து இயங்கக்கூடிய தனித்துவமான எடுத்துக்காட்டுகளுடன் விவாதிக்கப்படுகிறது. Go இல், தட்டச்சு செய்வது வெளிப்படையானது, இது வலுவான தட்டச்சுகளைச் செயல்படுத்துகிறது மற்றும் குறியீட்டின் தெளிவு மற்றும் நம்பகத்தன்மையை ஊக்குவிக்கிறது.