గోలాంగ్ జెనరిక్స్ ఉదాహరణలు

మరీ ముఖ్యంగా, జెనరిక్స్ గో యొక్క బలమైన రకం భద్రతను నిర్వహిస్తుంది, ఇది కంపైల్ సమయంలో స్టాటిక్ టైప్ చెకింగ్‌ని అనుమతిస్తుంది మరియు టైప్ ఖచ్చితత్వాన్ని నిర్ధారిస్తుంది. వారు సాధారణ కోడ్‌లో ప్రామాణిక లోపం నిర్వహణను అందిస్తారు, ఇది స్పష్టత మరియు నిర్వహణ సామర్థ్యాన్ని మెరుగుపరుస్తుంది. అదనంగా, వారు సాధారణ కోడ్‌లో ప్రామాణిక లోపం నిర్వహణను అందిస్తారు, ఇది స్పష్టత మరియు నిర్వహణ సామర్థ్యాన్ని మెరుగుపరుస్తుంది. ఈ పోస్ట్‌లో, మేము అనేక వాస్తవ-ప్రపంచ Go జెనరిక్స్ అప్లికేషన్‌లు మరియు ఉదాహరణలను పరిశీలిస్తాము.

ఉదాహరణ 1: గోలాంగ్ జెనరిక్ ఫంక్షన్‌ని ఉపయోగించడం

జెనరిక్స్ కోసం ప్రాథమిక వినియోగ సందర్భాలలో ఒకటి విభిన్న రకాలపై పనిచేసే ఫంక్షన్‌లను సృష్టించడం. ఇక్కడ, మేము సాధారణ చుట్టుకొలత ఫంక్షన్ ఉపయోగించే ఉదాహరణలలో ఒకదానితో వెళ్తాము.

మునుపటి కోడ్ ప్రారంభంలో, లైన్ 'fmt' ప్యాకేజీని దిగుమతి చేస్తుంది, ఇది కన్సోల్‌కు అవుట్‌పుట్‌ను ముద్రించడంతో సహా ఫార్మాట్ చేయబడిన I/O కోసం ఫంక్షన్‌లను అందిస్తుంది. అప్పుడు, మేము 'చుట్టుకొలత' అనే జెనరిక్ ఫంక్షన్‌ని నిర్వచిస్తాము, అది 'int' లేదా 'float32' కావచ్చు సాధారణ రకం 'r' యొక్క పారామీటర్ వ్యాసార్థాన్ని తీసుకుంటుంది. ఫంక్షన్ లోపల, ఇది వ్యాసార్థాన్ని “3” స్థిరమైన విలువతో గుణించి, ఆపై “2”తో గుణించడం ద్వారా చుట్టుకొలతను లెక్కిస్తుంది. చివరగా, ఇది 'fmt.Println' ఉపయోగించి లెక్కించిన చుట్టుకొలతను ముద్రిస్తుంది.

తరువాత, మనకు రెండు వేరియబుల్స్, r1 మరియు r2, డిక్లేర్ చేయబడి, వరుసగా 7 మరియు 7.5 విలువలతో కేటాయించబడే ప్రధాన ఫంక్షన్ ఉంది. ఆ తరువాత, 'చుట్టుకొలత' ఫంక్షన్ రెండుసార్లు అమలు చేయబడుతుంది, ఆర్1 మరియు r2 లను ఆర్గ్యుమెంట్‌లుగా పంపుతుంది.

అవుట్‌పుట్ కింది వాటిలో సర్కిల్‌ల చుట్టుకొలతలను ముద్రించడం ద్వారా గణనను ప్రదర్శిస్తుంది:

ఉదాహరణ 2:  గోలాంగ్ జెనరిక్ ఇంటర్‌ఫేస్‌ని ఉపయోగించడం

అంతేకాకుండా, గోలాంగ్ జెనరిక్స్ వాటి ఇంటర్‌ఫేస్‌లతో మాకు సహాయం చేస్తాయి. కోడ్ పునర్వినియోగం మరియు పాలిమార్ఫిజమ్‌ను సులభతరం చేయడానికి గోలోని ఇంటర్‌ఫేస్‌లు ఒక ముఖ్యమైన సాధనం. వాటిని అనేక రకాలతో పనిచేయడానికి వీలు కల్పించడం ద్వారా, జెనరిక్స్ ఇంటర్‌ఫేస్‌ల శక్తిని పెంచుతాయి. కిందిది గోలాంగ్ జెనరిక్స్ ఇంటర్‌ఫేస్ యొక్క సోర్స్ కోడ్:

మునుపటి సోర్స్ కోడ్‌లో, ఉద్యోగి వయస్సు కోసం సాధ్యమయ్యే రకాలను పేర్కొనే 'ఎంపేజ్' అనే ఇంటర్‌ఫేస్‌ను మేము నిర్వచించాము. ఇంటర్‌ఫేస్‌లో int64, int32, float32 మరియు float64 రకాలు ఉన్నాయి. ఈ ఇంటర్‌ఫేస్ 'జెనరిక్' ఫంక్షన్‌ను ఈ రకాల్లో దేనినైనా ఆర్గ్యుమెంట్‌గా అంగీకరించడానికి అనుమతిస్తుంది. ఆ తర్వాత, మేము కొత్తGenericFunc అనే జెనరిక్ ఫంక్షన్‌ని ఉపయోగిస్తాము, ఇది EmpAge ఇంటర్‌ఫేస్‌ను సంతృప్తిపరిచే ఏ రకమైన వయస్సు అయినా సాధారణ రకం వయస్సు యొక్క emp_Age పారామీటర్‌ను తీసుకుంటుంది. ఫంక్షన్ లోపల, ఇది emp_Ageని పూర్ణాంకానికి మారుస్తుంది మరియు చూపిన విధంగా దానిని 1కి పెంచుతుంది.

తరువాత, మేము Age1 మరియు Age2 అనే రెండు వేరియబుల్స్‌ని ప్రకటిస్తాము మరియు ప్రధాన ఫంక్షన్‌లో వరుసగా 24 మరియు 25.5 విలువలను కేటాయిస్తాము. ఆ తర్వాత, Age1 మరియు Age2 రెండుసార్లు అమలు చేయబడే newGenericFunc ఫంక్షన్‌కు పారామీటర్‌లుగా పాస్ చేయబడతాయి. దీనితో, వయస్సులు 1 పెంచబడతాయి మరియు నవీకరించబడిన విలువలను ఉత్పత్తి చేస్తాయి.

కింది వాటిలో లభించే అవుట్‌పుట్ ఇంటర్‌ఫేస్‌ను ఉపయోగించే జెనరిక్ ఫంక్షన్ నుండి వయస్సులు:

ఉదాహరణ 3: గోలాంగ్ జెనరిక్ డేటా స్ట్రక్చర్‌ని ఉపయోగించడం

ఇంకా, గో జెనరిక్స్ మాకు స్టాక్‌లు, క్యూలు మరియు లింక్డ్ లిస్ట్‌ల వంటి సాధారణ డేటా స్ట్రక్చర్‌లను రూపొందించే సామర్థ్యాన్ని కూడా అందిస్తుంది. కింది వాటిలో సాధారణ స్టాక్ అమలును పరిగణించండి:

మునుపటి కోడ్‌లో, స్టాక్‌ను సూచించే 'స్టాక్' పేరుతో ఒక సాధారణ రకం నిర్వచించబడింది. “T” ప్లేస్‌హోల్డర్ స్టాక్‌ను ఏ రకమైన ఎలిమెంట్‌లను అయినా పట్టుకోవడానికి అనుమతిస్తుంది. 'స్టాక్' రకం 'T' రకం మూలకాల స్లైస్‌గా అమలు చేయబడుతుంది. ఇక్కడ, 'స్టాక్' రకం కోసం రెండు విధులు అమలు చేయబడ్డాయి: 'పుష్' మరియు 'పాప్.' స్టాక్‌కు మూలకాలను జోడించడానికి పుష్() ఫంక్షన్ బాధ్యత వహిస్తుంది. ఇది 'T' రకం ఆర్గ్యుమెంట్ అంశాన్ని తీసుకుంటుంది మరియు append() ఫంక్షన్‌ని ఉపయోగించి అంతర్లీన స్లైస్‌కి జతచేస్తుంది.

Pop() ఫంక్షన్ స్టాక్ నుండి ప్రారంభ భాగాన్ని తీసుకుంటుంది మరియు దానిని తిరిగి ఇస్తుంది, ఇది ముందుగా అంతర్లీన స్లైస్ యొక్క పరిమాణాన్ని మూల్యాంకనం చేయడం ద్వారా స్టాక్ ఖాళీగా ఉందో లేదో నిర్ణయిస్తుంది. స్టాక్ ఖాళీగా ఉన్నట్లు కనిపిస్తే, అది భయాందోళనకు గురిచేస్తే ఎర్రర్ నోటిఫికేషన్ పంపబడుతుంది. లేకపోతే, ఇది స్లైస్ నుండి చివరి మూలకాన్ని తిరిగి పొందుతుంది, స్లైస్‌ను రెండవ నుండి చివరి మూలకం వరకు స్లైస్ చేయడం ద్వారా స్టాక్ నుండి తీసివేస్తుంది మరియు తీసివేయబడిన అంశాన్ని తిరిగి అందిస్తుంది.

తరువాత, ఈ కోడ్ యొక్క ప్రధాన విధిలో స్టాక్[int] సింటాక్స్ ఉపయోగించి పూర్ణాంకాల యొక్క కొత్త స్టాక్ సృష్టించబడుతుంది. ఆ తర్వాత, స్టాక్‌కు పూర్ణాంకాల 1, 2 మరియు 3ని జోడించడానికి 'పుష్' పద్ధతిని మూడుసార్లు పిలుస్తారు. అయినప్పటికీ, స్టాక్ నుండి మూలకాలను తిరిగి పొందడానికి మరియు ముద్రించడానికి 'పాప్' పద్ధతిని మూడుసార్లు పిలుస్తారు.

కింది అవుట్‌పుట్ మూలకాలు స్టాక్ నుండి రివర్స్ ఆర్డర్‌లో తీసివేయబడతాయని సూచిస్తుంది:

ఉదాహరణ 4: గోలాంగ్ సాధారణ పరిమితులను ఉపయోగించడం

Go అనుకూల పరిమితులను కూడా అందిస్తుంది, ఇది గొప్ప సౌలభ్యాన్ని ఎనేబుల్ చేస్తుంది మరియు వారి అప్లికేషన్ అవసరాల ఆధారంగా సాధారణ నిర్మాణాల కోసం నిర్దిష్ట అవసరాలను నిర్వచిస్తుంది. కస్టమ్ జెనరిక్ పరిమితుల కోడ్ ప్రదర్శన కోసం కింది వాటిలో అందించబడింది:

మునుపటి సోర్స్ కోడ్‌లో, మేము 'సమ్' పద్ధతితో న్యూమరిక్స్ ఇంటర్‌ఫేస్‌ని నిర్వచించాము. అప్పుడు, మేము 'FloatValue' మరియు 'IntegerValue' అనే రెండు అనుకూల రకాలను సృష్టిస్తాము, ఇవి వాటి సంబంధిత 'సమ్' పద్ధతులను అందించడం ద్వారా సంఖ్యల ఇంటర్‌ఫేస్‌ను అమలు చేస్తాయి. genericSum ఫంక్షన్ ఇప్పుడు న్యూమరిక్స్ ఇంటర్‌ఫేస్‌ను సంతృప్తిపరిచే ఏ రకమైన స్లైస్‌లను అయినా ఆమోదించగలదు. ఫంక్షన్ లోపల, మేము మూలకాలపై పునరావృతం చేస్తాము మరియు మొత్తాన్ని లెక్కించడానికి “సమ్” పద్ధతిని పిలుస్తాము. చివరగా, ప్రధాన ఫంక్షన్‌లో, మేము FloatValue మరియు IntegerValue స్లైస్‌లను సృష్టించి, వాటిని ప్రతి స్లైస్‌లోని మూలకాల మొత్తాన్ని సరిగ్గా గణించే genericSum() ఫంక్షన్‌కి పంపుతాము.

ఆశించిన అవుట్‌పుట్ ఇప్పుడు క్రింది స్క్రీన్‌లో కనిపిస్తుంది:

ముగింపు

మేము Go జెనరిక్స్ యొక్క కొన్ని ఆచరణాత్మక ఉదాహరణలను అన్వేషించాము, ఇందులో జెనరిక్ డేటా స్ట్రక్చర్ మరియు జెనరిక్ ఫంక్షన్‌ను రూపొందించడం, జెనరిక్ ఇంటర్‌ఫేస్‌ను నిర్వచించడం మరియు అనుకూల రకం పరిమితిని ఉపయోగించడం వంటివి ఉన్నాయి. ఈ ఉదాహరణలు గో ప్రోగ్రామింగ్ లాంగ్వేజ్‌కు జెనరిక్స్ తీసుకొచ్చే శక్తి మరియు సౌలభ్యాన్ని ప్రదర్శిస్తాయి. సంకలనం సమయంలో జెనరిక్స్ కోడ్ ఉత్పత్తి సమర్థవంతమైన బైనరీ పరిమాణం మరియు సంకలన సమయాలను నిర్ధారిస్తుంది.