இந்த கட்டுரையில், எவ்வாறு பயன்படுத்துவது என்பதை ஆராய்வோம் அறிக்கையைத் தேர்ந்தெடுக்கவும் கோலாங்கில் மற்றும் Go நிரல்களில் இணைநிலை, ஒத்திசைவு மற்றும் ஒத்திசைவு ஆகியவற்றை அடைய உதவும் எடுத்துக்காட்டுகளை வழங்கவும்.
கோலாங்கில் தேர்ந்தெடுக்கப்பட்ட அறிக்கையை எவ்வாறு பயன்படுத்துவது?
சுவிட்ச் ஸ்டேட்மெண்ட் போலவே, தி அறிக்கையைத் தேர்ந்தெடுக்கவும் பல வெளிப்பாடுகளில் ஒரு வெளிப்பாட்டைத் தேர்ந்தெடுத்து இயக்க அனுமதிக்கிறது, ஆனால் இடையே உள்ள முதன்மை வேறுபாடு தேர்ந்தெடுக்கவும் மற்றும் சுவிட்ச் என்பது அறிக்கையைத் தேர்ந்தெடுக்கவும் காத்திருப்பு கொள்கையில் செயல்படுகிறது, அதாவது அறிக்கையைத் தேர்ந்தெடுக்கவும் தகவல் தொடர்பு முடியும் வரை செயல்படுத்தாது.
இங்கே, தகவல் தொடர்பு என்பது கொடுக்கப்பட்ட எந்த சேனலுக்கும் தரவை அனுப்புதல் மற்றும் பெறுதல் என்பதைக் குறிக்கிறது. தகவல்தொடர்பு முடிந்ததும், அடுத்த சரிபார்ப்பு செய்யப்படுகிறது, இது Go மொழியின் தேர்ந்தெடுக்கப்பட்ட அறிக்கை முற்றிலும் சேனலைச் சார்ந்தது என்பதைக் காண அனுமதிக்கிறது.
தேர்வு அறிக்கைக்கான தொடரியல்
இதற்குப் பயன்படுத்தப்படும் எளிய தொடரியல் அறிக்கையைத் தேர்ந்தெடுக்கவும் Go மொழியைப் பயன்படுத்துவது கீழே காட்டப்பட்டுள்ளது:
தேர்ந்தெடுக்கவும் {
வழக்கு சேனல்_1 :
// சேனல்_1 தயாராக இருக்கும் போது செயல்படுத்த வேண்டிய குறியீடு
வழக்கு சேனல்_2 :
// சேனல்_2 தயாராக இருக்கும் போது செயல்படுத்த வேண்டிய குறியீடு
வழக்கு சேனல்_3 :
// channel_3 தயாராக இருக்கும் போது செயல்படுத்த வேண்டிய குறியீடு
வழக்கு சேனல்_4 :
// channel_4 தயாராக இருக்கும் போது செயல்படுத்த குறியீடு
இயல்புநிலை :
// சேனல்கள் எதுவும் தயாராக இல்லை என்றால் இயக்க குறியீடு
}
இங்கே:
- அக்குள் அறிக்கையைத் தேர்ந்தெடுக்கவும் , ஒவ்வொரு வழக்கும் ஒரு சேனல் செயல்பாட்டைக் குறிக்கிறது, இது பெறுதல் செயல்பாடு அல்லது அனுப்புதல் செயல்பாடு.
- தி அறிக்கையைத் தேர்ந்தெடுக்கவும் வழக்குகளில் ஒன்று தயாராகும் வரை காத்திருந்து பின்னர் அதை இயக்கவும் மற்றும் தொடர்புடைய வழக்கு அறிக்கையை இயக்கவும்.
- பல சேனல்கள் இயக்கத் தயாராக இருந்தால், இது தோராயமாக சேனலைத் தேர்ந்தெடுக்கும்.
கோலாங்கில் சேனலை உருவாக்குவது எப்படி
Go இல் சேனலை உருவாக்க, பயனர்கள் மேக் செயல்பாட்டைப் பயன்படுத்தலாம் சான் முக்கிய வார்த்தை மற்றும் சேனல் வகையை குறிப்பிடவும், இது முழு எண்ணாக இருக்கலாம், சரம் அல்லது பிற.
ch := செய்ய ( சான் வகை )கோலாங்கில் தேர்வு அறிக்கையை செயல்படுத்தவும்
இங்கே, பயன்படுத்துவதற்கான அடிப்படைகளை அறிய உங்களுக்கு உதவும் பல உதாரணங்களை நாங்கள் வழங்குவோம் அறிக்கையைத் தேர்ந்தெடுக்கவும் கோலாங்கில்.
எடுத்துக்காட்டு 1
பின்வரும் உதாரணம் அறிக்கையைத் தேர்ந்தெடுக்கவும் இரண்டு சேனல்களும் இயக்கத் தயாராக இருக்கும்போது அது எவ்வாறு செயல்படுகிறது என்பதை நிரூபிக்கிறது.
முக்கிய தொகுப்புஇறக்குமதி 'fmt'
முக்கிய செயல்பாடு ( ) {
ஒன்றில் := செய்ய ( சான் முழு எண்ணாக )
str := செய்ய ( சான் சரம் )
chan_num செல் ( ஒன்றில் )
போ chan_str ( str )
தேர்ந்தெடுக்கவும் {
வழக்கு Ch1 := <- ஒன்றில் :
fmt Println ( 'சேனல் தரவு:' , Ch1 )
வழக்கு Ch2 := <- str :
fmt Println ( 'சேனல் தரவு:' , Ch2 )
}
}
func chan_num ( எண் சான் முழு எண்ணாக ) {
ஒன்றில் <- 67
}
func chan_str ( str சான் சரம் ) {
str <- 'லினக்ஸ்'
}
மேலே உள்ள எடுத்துக்காட்டில், நாங்கள் இரண்டு சேனல்களை உருவாக்கினோம், ஒன்றில், மற்றும் str மற்றும் Go செயல்பாடுகளைப் பயன்படுத்தினோம் chan_num() எண் சேனலுக்கு தரவை அனுப்ப மற்றும் chan_str() str சேனலுக்கு தரவை அனுப்ப. நிரலில் இரண்டு வெவ்வேறு சேனல்கள் இருப்பதால், நாங்கள் அதைப் பயன்படுத்தினோம் அறிக்கையைத் தேர்ந்தெடுக்கவும் அவற்றில் ஒன்றை நிறைவேற்ற வேண்டும்.
வழக்கு Ch1 இலிருந்து மதிப்பைப் படிக்கிறது எண் சேனல் மற்றும் அதை காட்டுகிறது. இதேபோல், வழக்கு Ch2 இலிருந்து மதிப்பை வழங்குகிறது str சேனல். மேலே உள்ள நிரல் பயன்படுத்தத் தயாராக இருக்கும் சேனலின் வெளியீட்டை வழங்குகிறது. வெளியீடு
உதாரணம் 2
நீங்கள் ஒரு சேனலில் தாமதத்தைச் சேர்த்து மற்றொரு சேனலின் வெளியீட்டை வழங்க விரும்பினால், நீங்கள் இதைப் பயன்படுத்தலாம் நேரம்.தூக்கம்() ஒரு குறிப்பிட்ட சேனலில் செயல்பாடு. இது மற்ற சேனலின் வெளியீட்டை கன்சோலில் அச்சிட உங்களை அனுமதிக்கிறது. அத்தகைய வழக்குக்கான உதாரணம் இங்கே.
முக்கிய தொகுப்புஇறக்குமதி (
'fmt'
'நேரம்'
)
முக்கிய செயல்பாடு ( ) {
ஒன்றில் := செய்ய ( சான் முழு எண்ணாக )
str := செய்ய ( சான் சரம் )
chan_num செல் ( ஒன்றில் )
போ chan_str ( str )
தேர்ந்தெடுக்கவும் {
வழக்கு Ch1 := <- ஒன்றில் :
fmt Println ( 'சேனல் தரவு:' , Ch1 )
வழக்கு Ch2 := <- str :
fmt Println ( 'சேனல் தரவு:' , Ch2 )
}
}
func chan_num ( எண் சான் முழு எண்ணாக ) {
ஒன்றில் <- 67
}
func chan_str ( str சான் சரம் ) {
நேரம் . தூங்கு ( 5 * நேரம் . இரண்டாவது )
str <- 'லினக்ஸ்'
}
மேலே கொடுக்கப்பட்ட குறியீட்டில், நாங்கள் பயன்படுத்தினோம் நேரம். தூக்கம்() உள்ளே செயல்பாடு chan_str() செயல்பாடு. எண் சேனல் மட்டுமே முதல் 5 வினாடிகளுக்குச் செயல்படுத்தத் தயாராக உள்ளது. இதன் விளைவாக, தி அறிக்கையைத் தேர்ந்தெடுக்கவும் வழக்கு ஓடுகிறது Ch1 .
வெளியீடு
குறிப்பு: சேனல்களை இயக்குவதைத் தாமதப்படுத்த, இரண்டு சேனல்களிலும் தாமதத்தைச் சேர்க்கலாம்.
முடிவுரை
தி அறிக்கையைத் தேர்ந்தெடுக்கவும் in Go காத்திருப்பு கொள்கையைப் பயன்படுத்தி பல வெளிப்பாடுகளில் ஒரு வெளிப்பாட்டைத் தேர்ந்தெடுத்து செயல்படுத்த அனுமதிக்கிறது, அங்கு தகவல் தொடர்பு முடியும் வரை அறிக்கை செயல்படுத்தப்படாது. மேலே குறிப்பிடப்பட்ட வழிகாட்டுதல்கள் அடங்கும் அறிக்கையைத் தேர்ந்தெடுக்கவும் அடிப்படை தொடரியல் மற்றும் எடுத்துக்காட்டுகள்.