ఈ గైడ్ ఉపయోగాన్ని అన్వేషిస్తుంది లోపం.కొత్త() ఉదాహరణలతో గోలో ఫంక్షన్.
లోపాలు అంటే ఏమిటి.గోలాంగ్‌లో కొత్త() ఫంక్షన్
ది లోపాలు.కొత్త() స్ట్రింగ్‌ను ఆర్గ్యుమెంట్‌గా తీసుకుంటుంది మరియు అందించిన స్ట్రింగ్‌ను దాని కంటెంట్‌గా కలిగి ఉన్న కొత్త ఎర్రర్ మెసేజ్‌ను సూచించే ఎర్రర్ రకాన్ని చూపుతుంది కాబట్టి కొత్త ఎర్రర్ మెసేజ్‌ని సృష్టించడానికి గోలో అంతర్నిర్మిత ఫంక్షన్ ఉపయోగించబడుతుంది.
Goతో పని చేస్తున్నప్పుడు, లోపాలను సరిగ్గా నిర్వహించడం చాలా అవసరం. మీ కోడ్ ఊహించిన విధంగా ప్రవర్తించేలా మరియు ఊహించని పరిస్థితులను సునాయాసంగా నిర్వహించేలా ఎర్రర్ హ్యాండ్లింగ్ మీకు సహాయపడుతుంది. ది లోపాలు.కొత్త() ఫంక్షన్ మీ కోడ్‌లో ఊహించని దృశ్యాలను నిర్వహించడానికి అనుకూల దోష సందేశాలను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది.
ఒక సాధారణ వాక్యనిర్మాణం క్రింద చూడవచ్చు:
లోపాలు. కొత్తది ( సందేశం )
ఇక్కడ సందేశం అనేది మీరు వినియోగదారుకు ప్రదర్శించాలనుకుంటున్న దోష సందేశం.
Errors.New() ఫంక్షన్ ఎలా ఉపయోగించాలి?
ఉపయోగించాల్సిన దశలు ఇక్కడ ఉన్నాయి లోపాలు.కొత్త() గోలో ఫంక్షన్:
దశ 1: ముందుగా, మీరు మీ ఫైల్ ఎగువన కింది కోడ్ లైన్‌ను చేర్చడం ద్వారా మీ గో ప్రోగ్రామ్‌లోకి ఎర్రర్‌ల ప్యాకేజీని దిగుమతి చేసుకోవాలి:
దిగుమతి 'తప్పులు'
దశ 2: తర్వాత, కొత్త లోపాన్ని రూపొందించడానికి errors.New() ఫంక్షన్‌కు కాల్ చేయండి. మీరు ప్రదర్శించాలనుకుంటున్న దోష సందేశం స్ట్రింగ్‌లో చేర్చబడింది, అది ఫంక్షన్‌కు ఆర్గ్యుమెంట్‌గా పంపబడుతుంది. ఉదాహరణకి:
తప్పు := లోపాలు. కొత్తది ( 'ఫైల్ కనుగొనబడలేదు' )దశ 3: if స్టేట్‌మెంట్‌ని ఉపయోగించి మీ కోడ్‌లోని లోపాన్ని నిర్వహించండి. ఉదాహరణకి:
ఉంటే తప్పు != శూన్యం {// లోపాన్ని పరిష్కరించండి
}
ఎలా ఉపయోగించాలో ఇక్కడ ఒక ఉదాహరణ ఉంది లోపాలు.కొత్త() గోలో ఫంక్షన్:
ప్యాకేజీ ప్రధానదిగుమతి (
'తప్పులు'
'fmt'
)
ఫంక్ మెయిన్ ( ) {
సందేశం := 'శుభాకాంక్షలు'
లోపం := లోపాలు. కొత్తది ( 'చెల్లని సందేశం' )
ఉంటే సందేశం != 'Linux' {
fmt Println ( లోపం )
}
}
పై ఉదాహరణలో, మేము ఉపయోగించాము లోపాలు.కొత్త() లోపం సృష్టించడానికి ఫంక్షన్. అనుకూల దోష సందేశం “చెల్లని సందేశం” లోపల లోపం.కొత్త() ఈ సందర్భంలో ఫంక్షన్.
ఇక్కడ మరొక ఉదాహరణ:
ప్యాకేజీ ప్రధానదిగుమతి (
'తప్పులు'
'fmt'
)
ఫంక్ విభజన ( ఎ, బి int ) ( int , లోపం ) {
ఉంటే బి == 0 {
తిరిగి 0 , లోపాలు. కొత్తది ( 'సున్నాతో భాగించటం' )
}
తిరిగి a / బి, నిల్
}
ఫంక్ మెయిన్ ( ) {
ఫలితంగా, తప్పు := విభజించు ( 10 , 0 )
ఉంటే తప్పు != శూన్యం {
fmt Println ( 'లోపం:' , తప్పు )
తిరిగి
}
fmt Println ( 'ఫలితం:' , ఫలితం )
}
పై ఉదాహరణలో, మేము a ని నిర్వచించాము విభజించు() రెండు పూర్ణాంకాలను ఆర్గ్యుమెంట్‌లుగా తీసుకుని వాటి విభజనను తిరిగి ఇచ్చే ఫంక్షన్. రెండవ ఆర్గ్యుమెంట్ b 0 అయితే, మేము ఉపయోగించి ఎర్రర్‌ను అందిస్తాము లోపాలు.కొత్త() అనుకూల దోష సందేశంతో ఫంక్షన్ 'సున్నాతో భాగించటం' . మేము 10 మరియు 0 వాదనలతో కూడిన డివిజన్() ఫంక్షన్‌ని ప్రధాన ఫంక్షన్‌గా పిలుస్తాము, దీని ఫలితంగా లోపం ఏర్పడుతుంది. అప్పుడు, లోపం శూన్యం కానప్పుడు, అది శూన్యంగా ఉందో లేదో తనిఖీ చేసి, సందేశాన్ని ప్రింట్ చేస్తాము. లోపం శూన్యం అయితే, మేము ఫలితాన్ని ముద్రిస్తాము.
ముగింపు
ది లోపాలు.కొత్త() గోలోని ఫంక్షన్ లోపాలను నిర్వహించడానికి మరియు మీ కోడ్‌లో అనుకూల దోష సందేశాలను రూపొందించడానికి ఉపయోగపడుతుంది. ఈ గైడ్‌లో వివరించిన సాధారణ దశలను మరియు అందించిన ఉదాహరణలను అనుసరించడం ద్వారా, మీరు మీ ప్రోగ్రామ్‌లను డీబగ్ చేయడానికి మరియు ట్రబుల్షూట్ చేయడానికి ఈ ఫంక్షన్‌ను సమర్థవంతంగా ఉపయోగించవచ్చు. సరైన ఎర్రర్ హ్యాండ్లింగ్‌తో, మీరు మరింత పటిష్టమైన మరియు విశ్వసనీయమైన కోడ్‌ను వ్రాయవచ్చు, మీ ప్రోగ్రామ్‌లను మరింత స్థిరంగా మరియు వినియోగదారు-స్నేహపూర్వకంగా చేస్తుంది.