கோ உடன் நான்காவது நாள்

மீண்டும் வணக்கம்!

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

சரங்களை உருவாக்குதல்

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

சரத்தை வெட்டுவதற்கான தொடரியல்

new_arr = arr[1:]
// மேலே உள்ள ஸ்லைஸ், தொடக்கப் புள்ளியை குறியீட்டு ஒன்றிலிருந்து, முடிவு புள்ளியை சரத்தின் நீளம் வரை நீட்டிக்கும்.

// வெளியீடு: {4,8}

new_arr1 = arr[:2]
// மேலே உள்ள ஸ்லைஸ் தொடக்கப் புள்ளியை குறியீட்டு பூஜ்யத்திலும், முடிவு புள்ளியை குறிப்பிட்ட குறியீட்டு வரை நீட்டிக்கும்.

// வெளியீடு: {1,4}

மேலே உள்ள நிரல் துணுக்கு வரையறுக்கப்பட்ட மதிப்புகளுடன் 3 அளவுகொண்ட சரத்தை உருவாக்குகிறது.

ஸ்லைஸ் ஆபரேட்டர் : ஐப் பயன்படுத்தி சரங்களை வெட்டலாம். நமது விருப்பத்திற்கு ஏற்ப சரங்களை கையாள இது உதவும். எனது புரிதலின் படி ஸ்லைசிங் ஆபரேட்டர் பைத்தானில் உள்ளதைப் போலவே செயல்படுகிறது. எனவே, நான் இதைப் பற்றி மேலும் விவாதிக்கப் போவதில்லை.

மாறும் அளவிலான சரங்கள்

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

தொடரியல்

arr := []int{1,2,3,4,5}

இடத்தொடரியல் ஒரு சாதாரண சரத்தை அமைக்கும் தொடரியல் போலவே உள்ளது, அனால் இதில் சரத்தின் அளவு தேவையில்லை.

மாறும் அளவிலான சரங்களை உருவாக்க இரண்டு வழிகள் உள்ளன,

1. make() செயல்பாடை பயன்படுத்தல்
2. சரத்தின் மாறியை அறிவித்த பிறகு append() செயல்பாடை பயன்படுத்தல்.

make() செயல்பாடு

make() இரண்டு கூற்றுகளை வாங்கிக்கொள்கிறது. அவை, வெற்று சரம் மற்றும் நாம் கட்டுமானம் செய்யும் சரத்தின் அளவு. இக்கூற்றுகளைக் கொண்டு make() மாறும் அளவிலான வெற்று சரத்தை உருவாக்குகிறது.

உதாரணம்

size := 3
arr := make([]int, 3)
// இது மூன்றளவுக் கொண்ட வெற்றுச்சரத்தை உருவாக்குகிறது.

சரத்தின் மாறியை அறிவித்த பிறகு append() செயல்பாடை பயன்படுத்தல்

சரத்தின் மாறியை அறிவித்த பிறகு append() செயல்பாடை பயன்படுத்தலில் இரண்டு விடயங்களை உற்றுநோக்கவேண்டி உள்ளது, அவை,

1. சரத்தின் மாரியை அறிவித்தல்
2. append() செயல்பாட்டைப் பயன்படுத்தி உருவாக்கப்பட்ட வெற்றுச்சரத்தில் மதிப்புகளை சேர்த்தல்

ஒரு உதாரணத்தைப் பார்ப்போம்,

உதாரணம்

var arr []int
// சரத்தின் மாரியை அறிவித்தல்

// சரத்தின் நிலை: []
arr = append(arr, 5)
// இந்த நிரல்வரி 5ஐ arr எனும் சரத்துடுன் இணைக்கிறது

// சரத்தின் நிலை: [5]

range சுற்றை பயன்படுத்தி சரத்தை சுற்று செய்தல்

for லூப்பைப் பயன்படுத்துவதற்குப் பதிலாக, பைத்தானில் உள்ள range போன்ற கோ‘வின் range loop ஐப் பயன்படுத்தலாம்.

சரங்களை குறியீடு-மதிப்பு ஜோடிகளாக நாம் சுற்று செய்யலாம்.

ஒரு எளிய range சுற்று கீழ் உள்ளது போல் இருக்கும்,

sliceArr := []int{1,2,3,4,5}
for _, element := range sliceArr {
    fmt.Println("element is:", element)
}

வெளியீடு

element is: 1
element is: 2
element is: 3
element is: 4
element is: 5

இன்று இது போதும் என்று எண்ணுகிறேன். இன்று நான் கடந்த மூன்று நாட்களாக நான் கற்றுக்கொண்டதை பயிற்சி செய்தேன். கோ பற்றி தெரிந்துகொள்ள இன்னும் நிறைய இருக்கிறது, அதை நோக்கி பயணிப்பேன் என்று நம்புகிறேன்.

உங்கள் நேரத்துக்கு நன்றி,

உங்களிடமிருந்து விடைப்பெருவது,

~கோரீ08