ఉదాహరణ 1: గోలాంగ్ బేసిక్ టైప్ కాస్టింగ్
గోలో ప్రత్యక్ష మరియు ప్రాథమిక కాస్టింగ్ ఉదాహరణతో ప్రారంభిద్దాం, ఎందుకంటే ఎక్కడైనా వేరియబుల్ రకాన్ని సవరించడానికి మాకు టైప్‌కాస్టింగ్ అవసరం.
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
)
ఫంక్ ప్రధాన () {
ఉంది x int = 31
మరియు := ఫ్లోట్64 ( x )
fmt . Println ( మరియు )
}
ఇక్కడ, మేము 'int' రకం యొక్క 'x' అనే వేరియబుల్‌ని ప్రకటించడం ద్వారా ప్రధాన ఫంక్షన్‌తో ప్రారంభిస్తాము మరియు దానిని 31 విలువతో కేటాయిస్తాము. తర్వాత, 'y' వేరియబుల్ షార్ట్‌హ్యాండ్ అసైన్‌మెంట్ ఆపరేటర్ ':=' ఉపయోగించి ప్రకటించబడుతుంది. “x”ని “float64”గా మార్చడం వల్ల ఏర్పడే “y” రకం కుడి వైపున ఉన్న వ్యక్తీకరణ నుండి స్వయంచాలకంగా నిర్ణయించబడుతుంది. కాబట్టి, ఈ ప్రోగ్రామ్‌లో, “x” విలువ “float64”గా మార్చబడుతుంది మరియు “y”కి కేటాయించబడుతుంది.
Goలో ప్రాథమిక కాస్టింగ్ నుండి తిరిగి పొందిన ఫలితాలు క్రింది విధంగా ప్రదర్శించబడతాయి:
ఉదాహరణ 2: గోలాంగ్ ఇంప్లిసిట్ టైప్ కాస్టింగ్
వివిధ రకాల మధ్య అవ్యక్త రకం కాస్టింగ్ అనుమతించబడదు. Go బలమైన టైపింగ్‌ని అమలు చేస్తుంది అంటే స్పష్టమైన మార్పిడి లేకుండా మనం నేరుగా ఒక రకం విలువను మరొక రకంగా కేటాయించలేము లేదా ఉపయోగించలేము. కింది వాటిలో, మేము గో ద్వారా మినహాయింపును సృష్టించే అవ్యక్త కాస్టింగ్‌ని అమలు చేయడానికి ప్రయత్నిస్తాము:
ప్యాకేజీ ప్రధాన
దిగుమతి 'fmt'
ఫంక్ ప్రధాన () {
ఉంది పూర్ణ సంఖ్య int = 9 . 08
fmt . ప్రింట్ఎఫ్ ( 'పూర్ణాంకం %g' , పూర్ణ సంఖ్య )
}
ఇక్కడ ప్రధాన() ఫంక్షన్‌తో ప్రారంభమయ్యే కోడ్ ఇక్కడ ఉంది, ఇక్కడ 'పూర్ణాంకం' వేరియబుల్ 'int' రకంతో ప్రకటించబడుతుంది. “పూర్ణాంకం” వేరియబుల్‌కు కేటాయించిన విలువ 9.08, ఇది ఫ్లోటింగ్ పాయింట్ నంబర్. మేము ఫ్లోటింగ్ పాయింట్ విలువను పూర్ణాంకం వేరియబుల్‌కు నేరుగా కేటాయించడానికి ప్రయత్నిస్తున్నందున, ఇది రకం అసమతుల్యత లోపానికి దారి తీస్తుంది. అప్పుడు, '%g' ఫార్మాట్ స్పెసిఫైయర్‌ని ఉపయోగించి 'పూర్ణాంకం' వేరియబుల్ విలువను ప్రింట్ చేయడానికి 'fmt' ప్యాకేజీ నుండి 'printf' ఫంక్షన్‌ని ఉపయోగిస్తాము.
ఊహించినట్లుగా, గోలాంగ్‌లో అవ్యక్త రకం కాస్టింగ్ ఆమోదయోగ్యం కాదు. మునుపటి అవ్యక్త రకం కాస్టింగ్ కింది లోపాన్ని సృష్టిస్తుంది:
ఉదాహరణ 3: గోలాంగ్ స్పష్టమైన రకం కాస్టింగ్
స్పష్టమైన రకం మార్పిడి ఉద్దేశాన్ని స్పష్టంగా పేర్కొంటూ, అనుకూల రకాల మధ్య విలువలను సురక్షితంగా మార్చడానికి మాకు వీలు కల్పిస్తుంది. ఇది రకం మార్పిడి గురించి మాకు తెలుసని నిర్ధారిస్తుంది మరియు ప్రమాదవశాత్తు రకం లోపాలను నివారించడంలో సహాయపడుతుంది. కింది స్పష్టమైన కాస్టింగ్‌ను పరిగణించండి:
ప్యాకేజీ ప్రధానదిగుమతి 'fmt'
ఫంక్ ప్రధాన () {
ఉంది ఫ్లోట్వాల్ ఫ్లోట్32 = 6 . 75
ఉంది intVal int = int ( ఫ్లోట్వాల్ )
fmt . ప్రింట్ఎఫ్ ( 'ఫ్లోట్ విలువ %g \n ' , ఫ్లోట్వాల్ )
fmt . ప్రింట్ఎఫ్ ( 'పూర్ణాంకం విలువ %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'
ఫంక్ ప్రధాన () {
ఉంది మొత్తం int = 900
ఉంది నా సంఖ్య int = ఇరవై
ఉంది సగటు ఫ్లోట్32
సగటు = ఫ్లోట్32 ( మొత్తం ) / ఫ్లోట్32 ( నా సంఖ్య )
fmt . ప్రింట్ఎఫ్ ( 'సగటు = %f \n ' , సగటు )
}
ఇక్కడ, మేము మొదట మూడు వేరియబుల్స్ డిక్లేర్ చేస్తాము. 'మొత్తం' అనేది 900 విలువతో ప్రారంభించబడిన పూర్ణాంకం వేరియబుల్. 'MyNumber' అనేది 20 విలువతో ప్రారంభించబడిన ఒక పూర్ణాంకం వేరియబుల్. అప్పుడు కంప్యూటెడ్ సగటు float32 'సగటు' వేరియబుల్‌లో నిల్వ చేయబడుతుంది. గణనను నిర్వహించడానికి సగటు సూత్రం ఇవ్వబడుతుంది. విభజన ఫ్లోటింగ్ పాయింట్ డివిజన్‌గా జరిగిందని నిర్ధారించుకోవడానికి, టైప్ కన్వర్షన్‌ని ఉపయోగించి “టోటల్” మరియు “మైనెంబర్” విలువలు ఫ్లోట్32కి మార్చబడతాయి. లెక్కించిన సగటు 'సగటు' వేరియబుల్‌కు కేటాయించబడుతుంది. చివరగా, “printf” ఫంక్షన్‌లో ఉపయోగించిన “%f\n” ఫార్మాట్ స్ట్రింగ్ ఫ్లోట్ విలువను ప్రింట్ చేయాలి, దాని తర్వాత కొత్త లైన్ అక్షరం ఉండాలి అని నిర్దేశిస్తుంది.
మునుపటి కోడ్‌లో కాస్టింగ్ రకాన్ని సూచించిన తర్వాత ఫలిత విలువ సగటుగా పొందబడుతుంది:
ఉదాహరణ 5: గోలాంగ్ ఇంట్ మరియు స్ట్రింగ్ టైప్ కాస్టింగ్
అదనంగా, Go Int మరియు స్ట్రింగ్ రకాల మధ్య ప్రసారాన్ని కూడా అందిస్తుంది. strconv ప్యాకేజీ యొక్క ఫంక్షన్‌ని ఉపయోగించి మనం దీనిని సాధించగలము.
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
'strconv'
)
ఫంక్ ప్రధాన () {
ఉంది str స్ట్రింగ్ = '1999'
లో , _ := strconv . ట్రైలర్ ( లు )
fmt . Println ( లో )
ఉంది పూర్ణ సంఖ్య int = 1999
toStr := strconv . మునిగిపోయాడు ( పూర్ణ సంఖ్య )
fmt . Println ( toStr )
}
రెండు వేరియబుల్స్ డిక్లరేషన్‌తో ప్రారంభమయ్యే కోడ్ ఇక్కడ ఉంది. 'str' అనేది '1999' విలువతో ప్రారంభించబడిన స్ట్రింగ్ వేరియబుల్ మరియు 'పూర్ణాంకం' అనేది '1999' విలువతో ప్రారంభించబడిన పూర్ణాంక వేరియబుల్. ఆ తర్వాత, “strconv.Atoi()” ఫంక్షన్ “str” స్ట్రింగ్‌ను పూర్ణాంకం విలువకు మార్చడానికి ఉపయోగించబడుతుంది. 'v' యొక్క తిరిగి వచ్చిన విలువ మార్చబడిన పూర్ణాంకాన్ని సూచిస్తుంది మరియు Atoi() ద్వారా అందించబడిన ఏదైనా సంభావ్య లోపాన్ని విస్మరించడానికి ఖాళీ '_' ఐడెంటిఫైయర్ ఉపయోగించబడుతుంది.
తరువాత, పూర్ణాంకాన్ని స్ట్రింగ్ విలువకు మార్చడానికి strconv.Itoa() ఫంక్షన్ ఉపయోగించబడుతుంది. తిరిగి వచ్చిన విలువ “toStr” మార్చబడిన స్ట్రింగ్‌ను సూచిస్తుంది.
అవుట్‌పుట్ “1999” స్ట్రింగ్ నుండి పూర్ణాంకానికి మరియు తిరిగి “1999” యొక్క అసలు విలువను ఉత్పత్తి చేసే స్ట్రింగ్‌కు మార్చడాన్ని ప్రదర్శిస్తుంది:
ఉదాహరణ 6: స్ట్రింగ్ మరియు బైట్‌ల మధ్య గోలాంగ్ టైప్ కాస్టింగ్
అంతేకాకుండా, గోలోని కాస్టింగ్ స్ట్రింగ్ మరియు బైట్ రకాల్లో కూడా నిర్వహించబడుతుంది. కింది కోడ్‌లు స్ట్రింగ్‌లు మరియు బైట్ స్లైస్‌ల మధ్య మార్పిడిని ప్రదర్శిస్తాయి:
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
)
ఫంక్ ప్రధాన () {
ఉంది mystr స్ట్రింగ్ = 'హే అక్కడ'
ఉంది b1 [] బైట్ = [] బైట్ ( myStr )
fmt . Println ( b1 )
స్ట్రింగ్ := స్ట్రింగ్ ( b1 )
fmt . Println ( స్ట్రింగ్ )
}
ఇక్కడ, వేరియబుల్స్ మొదట 'myStr' మరియు 'b1' గా ప్రకటించబడతాయి, ఇవి నిర్దిష్ట విలువలతో ప్రారంభించబడతాయి. అప్పుడు, []byte(myStr) వ్యక్తీకరణ టైప్ కన్వర్షన్‌ని ఉపయోగించి “myStr” స్ట్రింగ్‌ను బైట్ స్లైస్‌గా మారుస్తుంది. ఇది ఫలిత బైట్ స్లైస్‌ను “b1” వేరియబుల్‌కు కేటాయిస్తుంది. ఆ తర్వాత, “స్ట్రింగ్(b1)” ఎక్స్‌ప్రెషన్ బైట్ స్లైస్ b1ని టైప్ కన్వర్షన్‌ని ఉపయోగించి తిరిగి స్ట్రింగ్‌గా మారుస్తుంది. ఇది ఫలిత స్ట్రింగ్‌ను “toString” వేరియబుల్‌కు కేటాయిస్తుంది.
అవుట్‌పుట్ కింది వాటిలో “హే దేర్” స్ట్రింగ్ మరియు దాని సంబంధిత బైట్ స్లైస్ ప్రాతినిధ్యం మధ్య మార్పిడిని చూపుతుంది:
ఉదాహరణ 7: స్క్వేర్ రూట్ పొందడానికి గోలాంగ్ టైప్ కాస్టింగ్
ఇప్పుడు, వర్గమూల ఫలితాలను కనుగొనడానికి గోలో కాస్టింగ్ చేస్తాము. కోడ్ ఈ క్రింది విధంగా ఉంచబడింది:
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
'గణితం'
)
ఫంక్ ప్రధాన () {
ఉంది n int = 177
ఉంది SqrtN ఫ్లోట్64
SqrtN = గణితం . చ ( ఫ్లోట్64 ( n ))
fmt . ప్రింట్ఎఫ్ ( '%d యొక్క వర్గమూలం %.2f \n ' , n , SqrtN )
}
ఇక్కడ, “n” వేరియబుల్ పూర్ణాంకంగా ప్రకటించబడింది మరియు “144” విలువను కేటాయిస్తుంది. “SqrtN” వేరియబుల్ ఫ్లోట్64గా ప్రకటించబడింది మరియు “n” యొక్క లెక్కించబడిన వర్గమూలాన్ని నిల్వ చేస్తుంది. అప్పుడు, 'n' యొక్క వర్గమూలాన్ని లెక్కించడానికి math.Sqrt() ఫంక్షన్ అమలు చేయబడుతుంది. math.Sqrt() float64 ఆర్గ్యుమెంట్‌ను ఆశించడం వలన మరియు “n” విలువ float64(n)ని ఉపయోగించి float64కి మార్చబడుతుంది. ఆ తర్వాత, పూర్ణాంకం విలువ (%d) మరియు ఫ్లోటింగ్ పాయింట్ విలువ (%.2f)ని పేర్కొనే “printf” ఫంక్షన్‌లో “%d స్క్వేర్ రూట్ %.2f\n” ఫార్మాట్ స్ట్రింగ్ కాల్‌లు. “%.2f”లోని “.2” ఖచ్చితత్వ నిర్దేశకం వర్గమూలం రెండు దశాంశ స్థానాలతో ముద్రించబడిందని నిర్ధారిస్తుంది.
ఇచ్చిన విలువ యొక్క వర్గమూలాన్ని సూచించే క్రింది అవుట్‌పుట్ పొందబడింది:
ముగింపు
గోలోని నటీనటులు అన్నీ ఎక్జిక్యూటబుల్ అయిన విభిన్న ఉదాహరణలతో చర్చించబడ్డాయి. Goలో, టైప్‌కాస్టింగ్ స్పష్టమైనది, ఇది బలమైన టైపింగ్‌ను అమలు చేస్తుంది మరియు కోడ్ స్పష్టత మరియు విశ్వసనీయతను ప్రోత్సహిస్తుంది.