Go అనేది బాగా ఇష్టపడే ప్రోగ్రామింగ్ భాష, దాని ప్రభావం, వేగం మరియు సామర్థ్యం కారణంగా ప్రజాదరణ పెరిగింది. అయితే, ఏదైనా ఇతర ప్రోగ్రామింగ్ లాంగ్వేజ్ మాదిరిగానే డెవలప్‌మెంట్ మరియు ఎగ్జిక్యూషన్ ఫేజ్‌లలో పొరపాట్లు జరగవచ్చు. మీ గో ప్రోగ్రామ్‌ల విశ్వసనీయత మరియు స్థిరత్వాన్ని నిర్ధారించడానికి లోపాలను సమర్థవంతంగా నిర్వహించడం చాలా అవసరం.
ఈ కథనం గోలో లోపాలను నిర్వహించడానికి అనేక పద్ధతులు మరియు సిఫార్సు చేసిన విధానాలను పరిశీలిస్తుంది.
గోలాంగ్‌లో లోపాలను నిర్వహించండి
గోలో, మీరు చేయవచ్చు లోపాలను నిర్వహించండి క్రింద పేర్కొన్న పద్ధతుల ద్వారా:
- కొత్త() ఫంక్షన్
- ఎర్రర్ఫ్() ఫంక్షన్
- స్పష్టమైన లోపం నిర్వహణ
- వాయిదా వేయండి, భయపడండి మరియు కోలుకోండి
- వ్రాపింగ్ లోపం
1: కొత్త() ఫంక్షన్
గో భాష అందిస్తుంది కొత్త() లోపాలను నిర్వహించడానికి ఫంక్షన్. ఈ ఫంక్షన్, అంతర్నిర్మిత ఎర్రర్‌ల ప్యాకేజీలో అందుబాటులో ఉంది, డెవలపర్లు వారి ప్రోగ్రామ్‌ల కోసం అనుకూల దోష సందేశాలను సృష్టించడానికి వీలు కల్పిస్తుంది. ఉపయోగించడం ద్వారా కొత్త() ఫంక్షన్, డెవలపర్లు లోపాలను సమర్థవంతంగా నిర్వహించగలరు మరియు వినియోగదారులకు అర్థవంతమైన దోష సందేశాలను అందించగలరు.
ప్యాకేజీ ప్రధాన
దిగుమతి 'తప్పులు'
దిగుమతి 'fmt'
ఫంక్ చెక్ ( పేరు స్ట్రింగ్ ) లోపం {
nError := errors.New ( 'చెల్లని పేరు' )
ఉంటే పేరు ! = 'Linux' {
తిరిగి తప్పు
}
తిరిగి శూన్యం
}
ఫంక్ మెయిన్ ( ) {
పేరు := 'Linux'
తప్పు := తనిఖీ ( పేరు )
ఉంటే తప్పు ! = లేదు {
fmt.Println ( తప్పు )
} లేకపోతే {
fmt.Println ( 'చెల్లుబాటు అయ్యే పేరు' )
}
}
పై కోడ్ ఉపయోగిస్తుంది కొత్త() చెక్పేరు స్ట్రింగ్ ఉంటే చూడటానికి ఫంక్షన్ Linux ఇచ్చిన పేరుతో సరిపోలుతుంది. ఫంక్షన్ సందేశంతో ఒక లోపాన్ని ఉత్పత్తి చేస్తుంది చెల్లని పేరు పేరు లేకపోతే Linux . పేరుకు సమానం అయితే ఎటువంటి లోపం లేదని చూపించడానికి ఫంక్షన్ శూన్యాన్ని అందిస్తుంది Linux .
పేరు వేరియబుల్ సెట్ చేయబడింది Linux ప్రధాన ఫంక్షన్ యొక్క కాల్‌లో చెక్పేరు ఫంక్షన్, ఇది పేరు వేరియబుల్‌ను ఆర్గ్యుమెంట్‌గా కూడా తీసుకుంటుంది. ప్రధాన విధి దోష సందేశాన్ని ప్రింట్ చేస్తుంది చెక్పేరు ఫంక్షన్ లోపాన్ని అందిస్తుంది. ప్రధాన విధిని ముద్రిస్తుంది చెల్లుబాటు అయ్యే పేరు ఉంటే చెక్పేరు ఫంక్షన్ nil తిరిగి వస్తుంది.
అవుట్‌పుట్
2: ఎర్రర్ఫ్() ఫంక్షన్
ది లోపం() గోలోని ఫంక్షన్ లోపాలను కూడా నిర్వహించడానికి అనుమతిస్తుంది. లోపం() దోష సందేశాన్ని ఫార్మాట్ చేసే ఎంపికను మాకు అందిస్తుంది. fmt ప్యాకేజీని దిగుమతి చేయడం ద్వారా, డెవలపర్లు తమ అవసరాలకు అనుగుణంగా దోష సందేశాలను అనుకూలీకరించడానికి దాన్ని ఉపయోగించుకోవచ్చు. లోపం() గోలో లోపాలను నిర్వహించడం మరియు తెలియజేయడం యొక్క సామర్థ్యాన్ని క్రమబద్ధీకరిస్తుంది మరియు మెరుగుపరుస్తుంది.
ప్యాకేజీ ప్రధానదిగుమతి 'fmt'
ఫంక్ డివి ( n1, n2 మీరు ) లోపం {
ఉంటే n2 == 0 {
తిరిగి fmt. లోపం ( '%d / %d \n సంఖ్యను సున్నాతో భాగించలేము' , n1, n2 )
}
తిరిగి శూన్యం
}
ఫంక్ మెయిన్ ( ) {
తప్పు := డివి ( 42 , 0 )
ఉంటే తప్పు ! = లేదు {
fmt.Printf ( 'లోపం: %s' , తప్పు )
} లేకపోతే {
fmt.Println ( 'చెల్లుబాటు అయ్యే డివిజన్' )
}
}
పై కోడ్‌లో, ది div ఫంక్షన్ n1 మరియు n2 అనే రెండు పూర్ణాంకాల ఇన్‌పుట్‌లను అంగీకరిస్తుంది మరియు n2 సున్నా అయితే, అది లోపాన్ని ఉత్పత్తి చేస్తుంది. ఫంక్షన్ n2 సున్నా అయితే n1 మరియు n2 విలువలను కలిగి ఉండే సందేశంతో ఎర్రర్‌ను ఉత్పత్తి చేస్తుంది. n2 సున్నా కాకపోతే ఎటువంటి లోపం లేదని చూపించడానికి ఫంక్షన్ శూన్యాన్ని అందిస్తుంది.
ప్రధాన ఫంక్షన్ 42 మరియు 0 విలువలతో divని నడుపుతున్నప్పుడు div రిటర్న్స్ చేసే ఎర్రర్ ఎర్రర్ వేరియబుల్‌లో సేవ్ చేయబడుతుంది. div ఫంక్షన్ లోపాన్ని అందించినట్లయితే ఎర్రర్ మెసేజ్‌ని ప్రదర్శించడానికి ప్రధాన ఫంక్షన్ fmt.Printfని ఉపయోగిస్తుంది. ప్రధాన ఫంక్షన్ ప్రింట్లు చెల్లుబాటు అయ్యే డివిజన్ div ఫంక్షన్ శూన్యాన్ని తిరిగి ఇస్తే.
అవుట్‌పుట్
3: స్పష్టమైన లోపం నిర్వహణ
తరచుగా మినహాయింపులపై ఆధారపడే ఇతర ప్రోగ్రామింగ్ భాషలతో పోలిస్తే గో స్పష్టమైన దోష నిర్వహణను ప్రోత్సహిస్తుంది. ఈ విధానం డెవలపర్‌లను ప్రయత్నించండి-క్యాచ్ బ్లాక్‌లపై ఆధారపడే బదులు, లోపాల కోసం స్పష్టంగా తనిఖీ చేయడానికి ఉంటే ఉపయోగించమని ప్రోత్సహిస్తుంది. ఇలా చేయడం వల్ల లోపాలను గుర్తించి సక్రమంగా సరిదిద్దుకునే అవకాశం ఉంటుంది. దీన్ని సులభతరం చేయడానికి, గో అందిస్తుంది తప్పు చేస్తే != నిల్ ప్రకటన, ఇది డెవలపర్‌లను ఫంక్షన్‌ని అమలు చేసిన తర్వాత లోపాలను తనిఖీ చేయడానికి మరియు ఫలితం ఆధారంగా తగిన చర్యలు తీసుకోవడానికి అనుమతిస్తుంది. స్పష్టమైన ఎర్రర్ హ్యాండ్లింగ్‌తో, ఎర్రర్ మేనేజ్‌మెంట్‌కు Go మరింత నిర్మాణాత్మకమైన మరియు నమ్మదగిన విధానాన్ని అందిస్తుంది.
ప్యాకేజీ ప్రధానదిగుమతి 'fmt'
ఫంక్ విభజన ( a, b ఫ్లోట్64 ) ( float64, లోపం ) {
ఉంటే b == 0 {
తిరిగి 0 , fmt.Errorf ( 'సున్నాతో భాగించలేము' )
}
తిరిగి a / బి, నిల్
}
ఫంక్ మెయిన్ ( ) {
ఫలితం, తప్పు := విభజన ( 13 , 3 )
ఉంటే తప్పు ! = లేదు {
fmt.Printf ( 'లోపం: %v \n ' , తప్పు )
} లేకపోతే {
fmt.Printf ( 'ఫలితం: %f \n ' , ఫలితం )
}
ఫలితం, తప్పు = విభజించు ( 23 , 0 )
ఉంటే తప్పు ! = లేదు {
fmt.Printf ( 'లోపం: %v \n ' , తప్పు )
} లేకపోతే {
fmt.Printf ( 'ఫలితం: %f \n ' , ఫలితం )
}
}
ఈ ఉదాహరణలో, విభజన ఫంక్షన్ రెండు విలువలను విభజించడానికి ఉపయోగించబడుతుంది. అవుట్‌పుట్ అనేది అలా చేయడం వల్ల వచ్చే ఫలితం. రెండవ సంఖ్య 0 అయితే, ఫంక్షన్ ఒక ప్రత్యేక దోష సందేశంతో లోపాన్ని ఉత్పత్తి చేస్తుంది.
ప్రధాన ఫంక్షన్‌లో విభజనను రెండుసార్లు అంటారు: ఒకసారి చెల్లుబాటు అయ్యే ఇన్‌పుట్‌లతో మరియు ఒకసారి చెల్లని ఇన్‌పుట్‌తో. ది, ఉంటే తప్పు != నిల్ విభజన ఫంక్షన్‌ని ఉపయోగించిన ప్రతిసారీ లోపం జరిగిందో లేదో తెలుసుకోవడానికి స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. ఒక దోష సందేశం సంభవించినట్లయితే ముద్రించబడుతుంది. కాకపోతే, ఫలితం ముద్రించబడుతుంది.
అవుట్‌పుట్
4: వాయిదా వేయండి, భయపడండి మరియు కోలుకోండి
గోలాంగ్ కూడా అందిస్తుంది వాయిదా వేయండి స్టేట్‌మెంట్, ఇది ప్రోగ్రామ్ లేదా నిర్దిష్ట కోడ్ బ్లాక్ పూర్తయిన తర్వాత ఫంక్షన్‌ని అమలు చేయడానికి ఉపయోగించబడుతుంది. ది వాయిదా వేయండి ప్రకటన తరచుగా దానితో కలిపి ఉపయోగించబడుతుంది కోలుకుంటారు రన్‌టైమ్ పానిక్ ఎర్రర్‌లను క్యాచ్ మరియు రికవర్ చేయడానికి ఫంక్షన్. రన్‌టైమ్ పానిక్ ఎర్రర్ ఏర్పడినప్పుడు, ది కోలుకుంటారు లోపం పరిస్థితి నుండి కోలుకోవడానికి మరియు ప్రోగ్రామ్ క్రాష్ కాకుండా నిరోధించడానికి ఫంక్షన్ ఉపయోగించబడుతుంది. ఫైల్‌లను మూసివేయడం, నెట్‌వర్క్ కనెక్షన్‌లను మూసివేయడం లేదా వనరులను విడుదల చేయడం వంటి క్లీన్-అప్ పనులకు ఇది ఉపయోగపడుతుంది. ఈ టాస్క్‌లను వాయిదా వేయడం ద్వారా, లోపం సంభవించినప్పటికీ అవి అమలు చేయబడతాయని మీరు నిర్ధారిస్తారు.
ది భయాందోళనలు ఊహించని లోపం సంభవించినప్పుడు ప్రోగ్రామ్ యొక్క సాధారణ అమలును ఆపడానికి ఉపయోగించబడుతుంది కోలుకుంటారు భయాందోళనలను నిర్వహించడానికి మరియు ప్రోగ్రామ్ యొక్క అమలును కొనసాగించడానికి ఉపయోగించబడుతుంది.
ప్యాకేజీ ప్రధానదిగుమతి 'fmt'
పానిక్ నుండి ఫంక్ రికవర్ ( ) {
ఉంటే r := కోలుకోండి ( ) ; ఆర్ ! = లేదు {
fmt.Println ( 'భయాందోళన నుండి కోలుకున్నారు:' , ఆర్ )
}
}
ఫంక్ విభజన ( x,y ఫ్లోట్64 ) ఫ్లోట్64 {
పానిక్ నుండి కోలుకోవడానికి వాయిదా వేయండి ( )
ఉంటే మరియు == 0 {
భయాందోళనలు ( 'సున్నాతో భాగించలేము' )
}
తిరిగి x / మరియు
}
ఫంక్ మెయిన్ ( ) {
fmt.Println ( విభజించు ( 13 , 3 ) )
fmt.Println ( విభజించు ( 23 , 0 ) )
}
పై కోడ్‌లో, రెండు ఫ్లోటింగ్ పాయింట్ విలువలను విభజించడానికి డివైడ్ ఫంక్షన్ ఉపయోగించబడుతుంది. అవుట్‌పుట్ అనేది అలా చేయడం వల్ల వచ్చే ఫలితం. రెండవ సంఖ్య సున్నా అయితే అనుకూలీకరించిన దోష సందేశం ఫంక్షన్ ద్వారా అవుట్‌పుట్ అవుతుంది. వాయిదా ప్రకటనను పిలవడానికి ఉపయోగించబడుతుంది పానిక్ నుండి కోలుకోండి ఫంక్షన్. ది పానిక్ నుండి కోలుకోండి ఫంక్షన్ విభజన ఫంక్షన్ లోపల జరిగిన భయాందోళనను గుర్తిస్తుంది మరియు అది జరిగినట్లయితే లోపాన్ని ముద్రిస్తుంది.
ప్రధాన ఫంక్షన్‌లో విభజనను రెండుసార్లు అంటారు: ఒకసారి చెల్లుబాటు అయ్యే ఇన్‌పుట్‌లతో మరియు ఒకసారి చెల్లని ఇన్‌పుట్‌తో. ది fmt.Println విభజన ఫంక్షన్ అమలు చేయబడిన ప్రతిసారీ ఫంక్షన్ ఫంక్షన్ యొక్క అవుట్‌పుట్‌ను ప్రింట్ చేస్తుంది. ది పానిక్ నుండి కోలుకోండి ఫంక్షన్ అది జరిగితే భయాందోళనను గుర్తిస్తుంది మరియు అది జరిగితే లోపాన్ని ప్రింట్ చేస్తుంది.
అవుట్‌పుట్
లోపాన్ని గుర్తించిన తర్వాత, ప్రోగ్రామ్ భయాందోళనల నుండి కోలుకుంది మరియు రన్ అవుతూనే ఉంది. అయినప్పటికీ, కోడ్ భయాందోళనకు గురైంది మరియు విభజించడానికి రెండవ కాల్‌లో విలువను అందించలేదు, అందుకే అది సున్నాని తిరిగి ఇచ్చింది.
5: ఎర్రర్ ర్యాపింగ్
గో అనే ఫీచర్ కూడా ఉంది చుట్టడంలో లోపం , ఇది దోష సందేశానికి అదనపు సందర్భాన్ని జోడించడానికి మిమ్మల్ని అనుమతిస్తుంది. సమస్యలను రికార్డ్ చేయడానికి లేదా ఎర్రర్ మెసేజ్‌లలో మరిన్ని వివరాలను అందించడానికి ఇది సహాయపడుతుంది. అసలైన లోపం మరియు అదనపు సందర్భాన్ని పొందుపరిచే ఎర్రర్ రకాన్ని సృష్టించడం ద్వారా ఇది సాధించబడుతుంది.
ప్యాకేజీ ప్రధానదిగుమతి 'తప్పులు'
దిగుమతి 'fmt'
ఫంక్ మెయిన్ ( ) {
ఉంటే తప్పు := బార్ ( ) ; తప్పు ! = లేదు {
fmt.Println ( తప్పు )
}
}
ఫంక్ విభజన ( a, b ఫ్లోట్64 ) ( float64, లోపం ) {
ఉంటే b == 0 {
తిరిగి 0 , లోపాలు.కొత్త ( 'సున్నాతో భాగించటం' )
}
తిరిగి a / బి, నిల్
}
ఫంక్ బార్ ( ) ( తప్పు లోపం ) {
_, తప్పు = విభజించు ( 42 , 0 )
ఉంటే తప్పు ! = లేదు {
తిరిగి fmt. లోపం ( 'గణించడంలో విఫలమైంది: %w' , తప్పు )
}
తిరిగి శూన్యం
}
పై కోడ్‌లో, విభజన ఫంక్షన్ ఈ ఉదాహరణలో రెండు సంఖ్యల నిష్పత్తిని గణిస్తుంది మరియు రెండవ విలువ సున్నా అయితే లోపాన్ని విసురుతుంది. బార్ ఫంక్షన్ డివైడ్ ఫంక్షన్‌ని పిలుస్తుంది మరియు ఆ లోపాన్ని చుట్టేస్తుంది విభజించు fmt.Errorf ఫంక్షన్‌ని ఉపయోగించి అసలు దోష సందేశాన్ని కలిగి ఉన్న సందేశంతో కొత్త ఎర్రర్‌లో తిరిగి వస్తుంది. బార్ ఫంక్షన్‌ను ప్రధాన ఫంక్షన్ ద్వారా పిలుస్తారు, ఇది తిరిగి వచ్చే ఏవైనా లోపాలను కూడా ప్రింట్ చేస్తుంది.
అవుట్‌పుట్
ముగింపు
సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ తప్పనిసరిగా ఉండాలి లోపం నిర్వహణ , మరియు గోలాంగ్‌లో వివిధ అంతర్నిర్మిత విధులు మరియు సునాయాసంగా చేయడం కోసం పద్ధతులు ఉన్నాయి. ఈ మెకానిజమ్‌లు డెవలపర్‌లను లోపాలను పట్టుకోవడానికి మరియు రికవర్ చేయడానికి, ప్రోగ్రామ్ క్రాష్‌లను నిరోధించడానికి మరియు తుది వినియోగదారులకు సమాచార దోష సందేశాలను అందించడానికి అనుమతిస్తాయి. ఈ ఎర్రర్-హ్యాండ్లింగ్ మెకానిజమ్‌లను సమర్థవంతంగా ఉపయోగించడం ద్వారా, డెవలపర్లు బలమైన, విశ్వసనీయమైన మరియు సమర్థవంతమైన సాఫ్ట్‌వేర్ అప్లికేషన్‌లను రూపొందించగలరు.