గోలాంగ్‌లోని ప్రతిబింబం రన్‌టైమ్‌లో డేటా స్ట్రక్చర్‌లు, రకాలు మరియు విలువలను పరిశీలించడానికి మరియు సవరించడానికి ప్రోగ్రామ్‌ను అనుమతిస్తుంది. ఇది రన్‌టైమ్‌లో ఏదైనా వేరియబుల్ రకం మరియు విలువను పరిశీలించడానికి, రకాల కొత్త ఉదాహరణలను సృష్టించడానికి మరియు ఇప్పటికే ఉన్న వేరియబుల్స్ విలువను సవరించడానికి అనుమతించే ఫంక్షన్‌ల సమితిని అందిస్తుంది. ఈ కథనం ప్రతిబింబ ప్యాకేజీలోని వివిధ గోలాంగ్ ఫంక్షన్‌లను కవర్ చేస్తుంది.
విషయ సూచిక
- గోలో ప్యాకేజీని ప్రతిబింబించండి
- ప్రతిబింబిస్తుంది.కాపీ() ఫంక్షన్
- ప్రతిబింబిస్తుంది.DeepEqual() ఫంక్షన్
- ప్రతిబింబిస్తుంది.స్వాపర్() ఫంక్షన్
- ప్రతిబింబిస్తుంది.TypeOf() ఫంక్షన్
- ప్రతిబింబిస్తుంది.ValueOf() ఫంక్షన్
- ముగింపు
గో అనేది స్థిరంగా టైప్ చేయబడిన భాష కాబట్టి కంపైల్ సమయంలో వేరియబుల్ రకం తెలుసుకోవాలి. అయితే, కొన్ని సందర్భాల్లో, ప్రోగ్రామ్ అమలు చేయబడే వరకు వాటి రకాలను నిర్ణయించలేని విలువలను నిర్వహించడం అవసరం కావచ్చు.
ఉదాహరణకు, మేము వివిధ రకాల ఆర్గ్యుమెంట్‌లతో పని చేయగల ఒక ఫంక్షన్‌ను వ్రాయవలసి రావచ్చు లేదా తెలియని రకాల డేటాను సీరియలైజ్ చేసి డీరియలైజ్ చేయాల్సి రావచ్చు. ఇక్కడే గోలాంగ్‌లో ప్రతిబింబ ప్యాకేజీ ఉపయోగించబడుతుంది.
గోలో ప్యాకేజీని ప్రతిబింబించండి
ప్రతిబింబ ప్యాకేజీ అనేది వాటి రకాలతో సంబంధం లేకుండా రన్‌టైమ్‌లో విలువలను తనిఖీ చేయడానికి మరియు మార్చడానికి మమ్మల్ని అనుమతించే ఫంక్షన్‌ల సమితిని అందిస్తుంది. ఈ ఫంక్షన్‌లతో, మేము ఏదైనా వేరియబుల్ రకం మరియు విలువ గురించి సమాచారాన్ని పొందవచ్చు, రకాల కొత్త ఉదాహరణలను సృష్టించవచ్చు మరియు ఇప్పటికే ఉన్న వేరియబుల్స్ విలువను సవరించవచ్చు.
గోలాంగ్‌లోని ప్రతిబింబ ప్యాకేజీ రెండు రకాలను కలిగి ఉంది: రకం మరియు విలువ. ఒక రకం పూర్ణాంకం, స్ట్రింగ్ లేదా అనుకూల నిర్మాణం వంటి గో రకాన్ని సూచిస్తుంది. విలువ 42 లేదా 'హలో' వంటి నిర్దిష్ట రకం విలువను సూచిస్తుంది.
రిఫ్లెక్ట్ ప్యాకేజీ కూడా వేరియబుల్స్ నుండి టైప్ మరియు వాల్యూ ఆబ్జెక్ట్‌లను పొందేందుకు అనుమతించే ఫంక్షన్‌ల సమితిని అందిస్తుంది. ఉదాహరణకు, reflect.TypeOf() ఫంక్షన్ వేరియబుల్ రకాన్ని సూచించే టైప్ ఆబ్జెక్ట్‌ని అందిస్తుంది, అయితే reflect.ValueOf() ఫంక్షన్ వేరియబుల్ విలువను చూపే విలువ వస్తువును ఇస్తుంది.
కింది విభాగాలలో, ప్రతిబింబ ప్యాకేజీలో సాధారణంగా ఉపయోగించే కొన్ని ఫంక్షన్‌లను మేము విశ్లేషిస్తాము.
ప్రతిబింబిస్తుంది.కాపీ() ఫంక్షన్
ప్రతిబింబ ప్యాకేజీ యొక్క ప్రతిబింబం.కాపీ() ఫంక్షన్ ఒక స్లైస్ విలువలను మరొక స్లైస్‌లోకి కాపీ చేయడానికి ఉపయోగించబడుతుంది. ఇది dst మరియు src అనే రెండు పారామీటర్‌లను తీసుకుంటుంది, రెండూ ఒకే మూలకం రకంతో స్లైస్ విలువలుగా ఉండాలి. ఫంక్షన్ src స్లైస్ నుండి విలువలను dst స్లైస్‌లోకి కాపీ చేస్తుంది మరియు కాపీ చేయబడిన మూలకాల సంఖ్యను అందిస్తుంది.
ప్రతిబింబం.కాపీ() ఫంక్షన్ క్రింది ఉదాహరణలో ప్రదర్శించబడింది:
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
'ప్రతిబింబించు'
)
ఫంక్ ప్రధాన () {
src := [] int { 1 , 2 , 3 , 4 , 5 }
dst := తయారు ([] int , మాత్రమే ( src ))
n := ప్రతిబింబిస్తాయి . కాపీ చేయండి ( ప్రతిబింబిస్తాయి . యొక్క విలువ ( dst ), ప్రతిబింబిస్తాయి . యొక్క విలువ ( src ))
fmt . Println ( n ) // అవుట్‌పుట్: 5
fmt . Println ( dst ) // అవుట్‌పుట్: [1 2 3 4 5]
}
ఈ ఉదాహరణలో, మేము కొన్ని పూర్ణాంకాల విలువలతో సోర్స్ స్లైస్ srcని మరియు src వలె అదే పొడవుతో డెస్టినేషన్ స్లైస్ dstని సృష్టిస్తాము. src నుండి dstకి విలువలను కాపీ చేయడానికి మరియు కాపీ చేయబడిన మూలకాల సంఖ్య (n) మరియు dst స్లైస్‌లోని కంటెంట్‌లను ప్రింట్ చేయడానికి మేము ప్రతిబింబం.కాపీ() అని పిలుస్తాము.
ప్రతిబింబిస్తుంది.DeepEqual() ఫంక్షన్
సమానత్వం కోసం రెండు విలువలను పోల్చడానికి ప్రతిబింబ ప్యాకేజీ యొక్క ప్రతిబింబం.DeepEqual() ఫంక్షన్ ఉపయోగించబడుతుంది. ఈ ఫంక్షన్‌లో a మరియు b అనే రెండు ఇన్‌పుట్ పారామీటర్‌లు ఉన్నాయి, రెండూ ఏ రకానికి చెందిన ఏదైనా విలువను కలిగి ఉంటాయి. a మరియు b లోతుగా సమానంగా ఉన్నట్లయితే, ఫంక్షన్ నిజాన్ని అందిస్తుంది, అంటే వాటి అంతర్లీన విలువలు పునరావృత సమానంగా ఉంటాయి. లేకపోతే, అది అబద్ధం అని తేలింది.
ప్రతిబింబం ఎలా ఉపయోగించాలో క్రింది ఉదాహరణ చూపిస్తుంది.DeepEqual():
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
'ప్రతిబింబించు'
)
ఫంక్ ప్రధాన () {
a := [] int { 1 , 2 , 3 }
బి := [] int { 1 , 2 , 3 }
ఉంటే ప్రతిబింబిస్తాయి . డీప్ ఈక్వల్ ( a , బి ) {
fmt . Println ( 'a మరియు b సమానం' )
} లేకపోతే {
fmt . Println ( 'a మరియు b సమానం కాదు' )
}
}
ఈ ఉదాహరణలో, మేము ఒకే పూర్ణాంక విలువలతో a మరియు b అనే రెండు స్లైస్‌లను సృష్టిస్తాము. అప్పుడు మనం రిఫ్లెక్ట్. డీప్ఈక్వల్() అని పిలుస్తాము, a మరియు b సమానత్వం కోసం సరిపోల్చండి మరియు ఫలితాన్ని ముద్రించండి.
ప్రతిబింబిస్తుంది.స్వాపర్() ఫంక్షన్
రిఫ్లెక్ట్ ప్యాకేజీ యొక్క ప్రతిబింబం.స్వాపర్() ఫంక్షన్ స్లైస్ యొక్క మూలకాలను మార్చగల ఫంక్షన్‌ను తిరిగి ఇవ్వడానికి ఉపయోగించబడుతుంది. ఇది ఒక పరామితి, v తీసుకుంటుంది, ఇది తప్పనిసరిగా స్లైస్ విలువ అయి ఉండాలి. ఫంక్షన్ i మరియు j అనే రెండు పూర్ణాంకాల పారామితులను తీసుకునే ఫంక్షన్‌ను అందిస్తుంది మరియు i మరియు j స్థానాల వద్ద స్లైస్ యొక్క మూలకాలను మార్చుకుంటుంది.
ప్రతిబింబం.స్వాపర్() యొక్క వినియోగాన్ని క్రింది ఉదాహరణ ద్వారా ప్రదర్శించవచ్చు:
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
'ప్రతిబింబించు'
)
ఫంక్ ప్రధాన () {
లు := [] int { 1 , 2 , 3 , 4 , 5 }
మార్పిడి := ప్రతిబింబిస్తాయి . మార్పిడి ( లు )
మార్పిడి ( 1 , 3 )
fmt . Println ( లు ) // అవుట్‌పుట్: [1 4 3 2 5]
}
ఈ ఉదాహరణలో, మేము కొన్ని పూర్ణాంక విలువలతో s అనే స్లైస్‌ని సృష్టించాము. స్లైస్‌లోని ఎలిమెంట్‌లను స్వాప్ చేయగల ఫంక్షన్ స్వాప్‌ని పొందడానికి మనం అప్పుడు రిఫ్లెక్ట్.స్వాపర్() అని పిలుస్తాము. మేము s స్లైస్‌లోని 1 మరియు 3 స్థానాల వద్ద మూలకాలను మార్చుకోవడానికి మరియు ఫలితాన్ని ముద్రించడానికి స్వాప్‌ని ఉపయోగిస్తాము.
ప్రతిబింబిస్తుంది.TypeOf() ఫంక్షన్
ప్రతిబింబం.TypeOf() విలువ యొక్క రకాన్ని పొందడానికి ఉపయోగించబడుతుంది. ఈ ఫంక్షన్ ఏ రకం లేదా విలువ అయినా ఒకే పరామితి “v”ని అంగీకరిస్తుంది. ఫంక్షన్ ప్రతిబింబిస్తుంది. విలువ యొక్క రకాన్ని సూచించే రకం విలువ.
ప్రతిబింబం.TypeOf() యొక్క వినియోగాన్ని క్రింది ఉదాహరణ ద్వారా ప్రదర్శించవచ్చు:
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
'ప్రతిబింబించు'
)
ఫంక్ ప్రధాన () {
ఉంది x ఫ్లోట్64 = 3 . 14
t := ప్రతిబింబిస్తాయి . రకం ( x )
fmt . Println ( t ) // అవుట్‌పుట్: float64
}
ఈ ఉదాహరణలో, మేము 3.14 విలువతో float64 వేరియబుల్ xని సృష్టిస్తాము. x రకాన్ని పొందడానికి మరియు ఫలితాన్ని ప్రతిబింబంలో నిల్వ చేయడానికి రిఫ్లెక్ట్.టైప్ఆఫ్() అని పిలుస్తాము. టైప్ వేరియబుల్ t. మేము t విలువను ముద్రిస్తాము, ఇది float64.
ప్రతిబింబిస్తుంది.ValueOf() ఫంక్షన్
ప్రతిబింబించే విలువ. ఇది ఒకే పరామితి vని తీసుకుంటుంది, ఇది ఏ రకమైన విలువ అయినా కావచ్చు. ఫంక్షన్ రిఫ్లెక్ట్. ఇన్‌పుట్ పరామితి యొక్క విలువను సూచించే విలువ విలువను అందిస్తుంది.
ప్రతిబింబం.ValueOf() యొక్క వినియోగాన్ని క్రింది ఉదాహరణ ద్వారా ప్రదర్శించవచ్చు:
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
'ప్రతిబింబించు'
)
ఫంక్ ప్రధాన () {
ఉంది x ఫ్లోట్64 = 3 . 14
లో := ప్రతిబింబిస్తాయి . యొక్క విలువ ( x )
fmt . Println ( లో ) // అవుట్‌పుట్: 3.14
}
ఈ ఉదాహరణలో, మేము 3.14 విలువతో float64 వేరియబుల్ xని సృష్టిస్తాము. మేము x యొక్క ప్రతిబింబ-విలువ ప్రాతినిధ్యాన్ని పొందడానికి మరియు రిఫ్లెక్ట్-వాల్యూ వేరియబుల్ vలో ఫలితాన్ని నిల్వ చేయడానికి ప్రతిబింబం.ValueOf() అని పిలుస్తాము. మేము v విలువను ప్రింట్ చేస్తాము, ఇది 3.14.
ప్రతిబింబించే ప్యాకేజీ పేర్కొన్న వాటికి మించి అనేక ఫంక్షన్‌లను అందిస్తుంది మరియు ఇవి కొన్ని ఉదాహరణలు మాత్రమే. రిఫ్లెక్ట్ ప్యాకేజీ అందించిన ఫంక్షన్‌లను ఉపయోగించడం ద్వారా, కంపైలేషన్ సమయంలో రకాన్ని తెలుసుకోవాల్సిన అవసరం లేకుండా, ఏ రకమైన విలువలతోనైనా పని చేయగల కోడ్‌ను మనం సృష్టించవచ్చు.
ముగింపు
గోలాంగ్‌లోని ప్రతిబింబం రన్‌టైమ్‌లో డేటా స్ట్రక్చర్‌లు, రకాలు మరియు విలువలను పరిశీలించడానికి మరియు సవరించడానికి ప్రోగ్రామ్‌ను అనుమతిస్తుంది. ఇది రిఫ్లెక్ట్ ప్యాకేజీ ద్వారా అమలు చేయబడుతుంది, ఇది రకాలు మరియు విలువలను తనిఖీ చేయడానికి మరియు మార్చడానికి ఫంక్షన్‌లను అందిస్తుంది. ఇంటర్‌ఫేస్‌లు, తెలియని రకాలు లేదా మీరు జెనరిక్ ఫంక్షన్‌లను అమలు చేయవలసి వచ్చినప్పుడు ప్రతిబింబం ప్రత్యేకంగా ఉపయోగపడుతుంది. రిఫ్లెక్ట్ ప్యాకేజీ, రిఫ్లెక్ట్ టైప్ అండ్ వాల్యూ మరియు డైనమిక్ టైప్ మరియు వాల్యూతో సహా గోలాంగ్‌లో ప్రతిబింబం యొక్క ప్రాథమికాలను ఈ వ్యాసం చర్చించింది.