گو ایک اچھی طرح سے پسند کی جانے والی پروگرامنگ زبان ہے جو اپنی تاثیر، رفتار اور کارکردگی کی وجہ سے مقبولیت میں اضافہ ہوا ہے۔ تاہم، ترقی اور عمل درآمد کے مراحل کے دوران غلطیاں ہو سکتی ہیں، بالکل اسی طرح جیسے کسی بھی دوسری پروگرامنگ زبان میں۔ آپ کے Go پروگراموں کی وشوسنییتا اور استحکام کو یقینی بنانے کے لیے غلطیوں کو مؤثر طریقے سے ہینڈل کرنا ضروری ہے۔
یہ مضمون Go میں غلطیوں کے انتظام کے لیے کئی طریقوں اور تجویز کردہ طریقہ کار کا جائزہ لے گا۔
گولانگ میں غلطیوں کو ہینڈل کریں۔
Go میں، آپ کر سکتے ہیں۔ غلطیوں کو ہینڈل کریں مندرجہ ذیل طریقوں کے ذریعے:
- نیا () فنکشن
- Errorf() فنکشن
- واضح نقص کو سنبھالنا
- موخر کریں، گھبراہٹ کریں، اور بازیافت کریں۔
- ریپنگ میں خرابی
1: نیا () فنکشن
گو زبان فراہم کرتا ہے۔ نئی() غلطیوں کو منظم کرنے کے لئے فنکشن. یہ فنکشن، بلٹ ان ایررز پیکج میں دستیاب ہے، ڈویلپرز کو اپنے پروگراموں کے لیے حسب ضرورت ایرر میسیجز بنانے کے قابل بناتا ہے۔ کا استعمال کرتے ہوئے نئی() فنکشن، ڈویلپرز غلطیوں کو مؤثر طریقے سے سنبھال سکتے ہیں اور صارفین کو بامعنی غلطی کے پیغامات فراہم کر سکتے ہیں۔
اہم پیکیج
درآمد 'غلطیاں'
درآمد 'fmt'
فنک چیک ( نام کی تار ) غلطی {
nError := errors.New ( 'غلط نام' )
اگر نام ! = 'لینکس' {
واپسی nغلطی
}
واپسی صفر
}
فنک مین ( ) {
نام := 'لینکس'
غلطی := چیک کریں۔ ( نام )
اگر غلطی ! = صفر {
fmt.Println ( غلطی )
} اور {
fmt.Println ( 'درست نام' )
}
}
مذکورہ کوڈ استعمال کرتا ہے۔ نئی() چیک نام فنکشن یہ دیکھنے کے لیے کہ آیا سٹرنگ لینکس دیئے گئے نام سے میل کھاتا ہے۔ فنکشن پیغام کے ساتھ ایک خرابی پیدا کرتا ہے۔ غلط نام اگر نام نہیں ہے لینکس . فنکشن صفر واپس کرتا ہے یہ ظاہر کرنے کے لیے کہ اگر نام کے برابر ہے تو کوئی خرابی نہیں تھی۔ لینکس .
نام متغیر پر سیٹ ہے۔ لینکس مین فنکشن کی کال میں چیک نام فنکشن، جو نام متغیر کو بطور دلیل بھی لیتا ہے۔ مرکزی فنکشن غلطی کے پیغام کو پرنٹ کرتا ہے اگر چیک نام فنکشن ایک غلطی واپس کرتا ہے۔ مرکزی فنکشن پرنٹ کرتا ہے۔ درست نام اگر چیک نام فنکشن صفر واپس کرتا ہے۔
آؤٹ پٹ
2: Errorf() فنکشن
دی غلطی() گو میں فنکشن ہمیں غلطیوں کو بھی سنبھالنے کی اجازت دیتا ہے۔ غلطی() ہمیں غلطی کے پیغام کو فارمیٹ کرنے کا اختیار دیتا ہے۔ ایف ایم ٹی پیکج کو درآمد کرکے، ڈویلپر اپنی ضروریات کے مطابق غلطی کے پیغامات کو اپنی مرضی کے مطابق بنانے کے لیے اس کا استعمال کرسکتے ہیں۔ غلطی() Go میں غلطیوں کو منظم کرنے اور پہنچانے کی کارکردگی کو ہموار اور بہتر بناتا ہے۔
اہم پیکیجدرآمد 'fmt'
func div ( n1، n2 آپ ) غلطی {
اگر n2 == 0 {
واپسی fmt.Errorf ( '%d / %d \n کسی نمبر کو صفر سے تقسیم نہیں کیا جا سکتا' ، n1، n2 )
}
واپسی صفر
}
فنک مین ( ) {
غلطی := div ( 42 , 0 )
اگر غلطی ! = صفر {
fmt.Printf ( 'خرابی: %s' ، غلطی )
} اور {
fmt.Println ( 'درست ڈویژن' )
}
}
مندرجہ بالا کوڈ میں، div فنکشن دو عدد ان پٹ کو قبول کرتا ہے، n1، اور n2، اور اگر n2 صفر ہے، تو یہ ایک خرابی پیدا کرتا ہے۔ فنکشن ایک پیغام کے ساتھ ایک خرابی پیدا کرتا ہے جس میں n1 اور n2 کی قدر ہوتی ہے اگر n2 صفر ہے۔ فنکشن صفر واپس کرتا ہے یہ ظاہر کرنے کے لیے کہ اگر n2 صفر نہیں ہے تو کوئی خرابی نہیں تھی۔
وہ ایرر جو div واپس کرتا ہے اسے ایرر ویری ایبل میں محفوظ کیا جاتا ہے جب مین فنکشن 42 اور 0 ویلیو کے ساتھ div چلاتا ہے۔ مین فنکشن fmt.Printf استعمال کرتا ہے اگر div فنکشن ایرر لوٹاتا ہے تو ایرر میسج کو ظاہر کرتا ہے۔ مرکزی فنکشن پرنٹ کرتا ہے۔ درست ڈویژن اگر div فنکشن صفر واپس کرتا ہے۔
آؤٹ پٹ
3: واضح نقص کو ہینڈل کرنا
گو دیگر پروگرامنگ زبانوں کے مقابلے میں واضح غلطی کے انتظام کی حوصلہ افزائی کرتا ہے، جو اکثر مستثنیات پر انحصار کرتی ہیں۔ یہ نقطہ نظر ڈویلپرز کو استعمال کرنے کی ترغیب دیتا ہے اگر بیانات کو واضح طور پر غلطیوں کی جانچ کرنے کے لیے، بجائے اس کے کہ ٹرائی کیچ بلاکس پر انحصار کریں۔ ایسا کرنے سے، غلطیوں کو تلاش کرنے اور مناسب طریقے سے حل کرنے کا امکان زیادہ ہے. اس کی سہولت کے لیے، Go فراہم کرتا ہے۔ اگر غلطی! = صفر بیان، جو ڈویلپرز کو فنکشن کو انجام دینے کے بعد غلطیوں کی جانچ کرنے اور نتیجہ کی بنیاد پر مناسب اقدامات کرنے کی اجازت دیتا ہے۔ واضح غلطی سے نمٹنے کے ساتھ، Go غلطی کے انتظام کے لیے زیادہ منظم اور قابل اعتماد طریقہ پیش کرتا ہے۔
اہم پیکیجدرآمد 'fmt'
تقریب تقسیم ( a، b float64 ) ( float64، غلطی ) {
اگر ب == 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 ' نتیجہ )
}
}
اس مثال میں، divide فنکشن دو قدروں کو تقسیم کرنے کے لیے استعمال کیا جاتا ہے۔ آؤٹ پٹ ایسا کرنے کا نتیجہ ہے۔ اگر دوسرا نمبر 0 ہے تو، فنکشن ایک الگ غلطی کے پیغام کے ساتھ ایک غلطی پیدا کرتا ہے۔
تقسیم کو مین فنکشن میں دو بار کہا جاتا ہے: ایک بار درست ان پٹ کے ساتھ اور ایک بار غلط ان پٹ کے ساتھ۔ اگر غلطی! = صفر سٹیٹمنٹ کا استعمال اس بات کا تعین کرنے کے لیے کیا جاتا ہے کہ آیا ہر بار جب ڈویژن فنکشن استعمال کیا جاتا ہے تو کوئی خرابی واقع ہوئی ہے۔ اگر کوئی ہوتا ہے تو ایک غلطی کا پیغام پرنٹ کیا جاتا ہے۔ اگر نہیں، تو نتیجہ پرنٹ کیا جاتا ہے.
آؤٹ پٹ
4: موخر کریں، گھبراہٹ کریں، اور بازیافت کریں۔
گولنگ بھی فراہم کرتا ہے۔ موخر کرنا بیان، جو کسی پروگرام یا کوڈ کے مخصوص بلاک کی تکمیل کے بعد کسی فنکشن کو انجام دینے کے لیے استعمال ہوتا ہے۔ دی موخر کرنا بیان اکثر کے ساتھ مل کر استعمال ہوتا ہے۔ وصولی رن ٹائم گھبراہٹ کی غلطیوں کو پکڑنے اور بازیافت کرنے کا فنکشن۔ جب رن ٹائم گھبراہٹ کی خرابی واقع ہوتی ہے، وصولی فنکشن کا استعمال خرابی کی حالت سے بازیافت کرنے اور پروگرام کو کریش ہونے سے روکنے کے لیے کیا جاتا ہے۔ یہ کلین اپ کاموں کے لیے مفید ہے جیسے فائلوں کو بند کرنا، نیٹ ورک کنکشن بند کرنا، یا وسائل جاری کرنا۔ ان کاموں کو موخر کر کے، آپ اس بات کو یقینی بناتے ہیں کہ اگر کوئی خرابی واقع ہو جائے تو بھی ان پر عمل درآمد ہو جاتا ہے۔
دی خوف و ہراس پروگرام کے معمول پر عمل درآمد کو روکنے کے لیے استعمال کیا جاتا ہے جب کوئی غیر متوقع خرابی واقع ہوتی ہے، جبکہ وصولی گھبراہٹ کو سنبھالنے اور پروگرام کو جاری رکھنے کے لیے استعمال کیا جاتا ہے۔
اہم پیکیجدرآمد 'fmt'
Panic سے func recover ( ) {
اگر r := بازیافت ( ) ; r ! = صفر {
fmt.Println ( 'گھبراہٹ سے بازیاب:' ،ر )
}
}
تقریب تقسیم ( ایکس، وائی فلوٹ64 ) float64 {
Panic سے وصولی کو موخر کریں۔ ( )
اگر اور == 0 {
خوف و ہراس ( 'صفر سے تقسیم نہیں کیا جا سکتا' )
}
واپسی ایکس / اور
}
فنک مین ( ) {
fmt.Println ( تقسیم ( 13 , 3 ) )
fmt.Println ( تقسیم ( 23 , 0 ) )
}
مندرجہ بالا کوڈ میں، divide فنکشن دو فلوٹنگ پوائنٹ ویلیو کو تقسیم کرنے کے لیے استعمال کیا جاتا ہے۔ آؤٹ پٹ ایسا کرنے کا نتیجہ ہے۔ ایک حسب ضرورت غلطی کا پیغام فنکشن کے ذریعہ آؤٹ پٹ ہے اگر دوسرا نمبر صفر ہے۔ ڈیفر سٹیٹمنٹ کو پکارنے کے لیے استعمال کیا جاتا ہے۔ Panic سے بازیافت فنکشن دی Panic سے بازیافت فنکشن ایک گھبراہٹ کا پتہ لگائے گا جو ڈویژن فنکشن کے اندر ہوا ہے اور اگر ایسا ہوا ہے تو ایک غلطی پرنٹ کرے گا۔
تقسیم کو مین فنکشن میں دو بار کہا جاتا ہے: ایک بار درست ان پٹ کے ساتھ اور ایک بار غلط ان پٹ کے ساتھ۔ دی fmt.Println فنکشن ہر بار جب ڈویژن فنکشن چلاتا ہے تو فنکشن کا آؤٹ پٹ پرنٹ کرتا ہے۔ دی Panic سے بازیافت فنکشن گھبراہٹ کا پتہ لگائے گا اگر ایسا ہوتا ہے اور اگر ایسا ہوتا ہے تو اسے پرنٹ کرے گا۔
آؤٹ پٹ
خرابی کا پتہ لگانے کے بعد، پروگرام گھبراہٹ سے باہر نکلا اور چلتا رہا۔ تاہم، کوڈ گھبرا گیا اور تقسیم کے لیے دوسری کال پر کوئی قدر واپس نہیں کی، یہی وجہ ہے کہ اس نے صفر واپس کیا۔
5: خرابی لپیٹنا
Go میں ایک خصوصیت بھی شامل ہے جسے جانا جاتا ہے۔ ریپنگ میں خرابی ، جو آپ کو غلطی کے پیغام میں اضافی سیاق و سباق شامل کرنے کی اجازت دیتا ہے۔ یہ مسائل کو ریکارڈ کرنے یا غلطی کے پیغامات میں مزید تفصیلات فراہم کرنے میں مددگار ہے۔ یہ غلطی کی قسم بنا کر پورا کیا جا سکتا ہے جو اصل غلطی اور اضافی سیاق و سباق کو سرایت کرتا ہے۔
اہم پیکیجدرآمد 'غلطیاں'
درآمد 'fmt'
فنک مین ( ) {
اگر غلطی := بار ( ) ; غلطی ! = صفر {
fmt.Println ( غلطی )
}
}
تقریب تقسیم ( a، b float64 ) ( float64، غلطی ) {
اگر ب == 0 {
واپسی 0 , غلطیاں۔نئی ( 'صفر سے تقسیم' )
}
واپسی a / ب، صفر
}
فنک بار ( ) ( غلطی غلطی ) {
_، غلطی = تقسیم ( 42 , 0 )
اگر غلطی ! = صفر {
واپسی fmt.Errorf ( 'حساب کرنے میں ناکام: %w' ، غلطی )
}
واپسی صفر
}
مندرجہ بالا کوڈ میں، divide فنکشن اس مثال میں دو نمبروں کے تناسب کی گنتی کرتا ہے اور اگر دوسری قدر صفر ہے تو غلطی پھینکتا ہے۔ بار فنکشن تقسیم فنکشن کو کال کرتا ہے اور پھر اس غلطی کو لپیٹ دیتا ہے۔ تقسیم fmt.Errorf فنکشن کا استعمال کرتے ہوئے ایک نئے ایرر میں ایک پیغام کے ساتھ واپس آتا ہے جس میں اصل ایرر میسج شامل ہوتا ہے۔ بار فنکشن کو مین فنکشن کے ذریعہ کہا جاتا ہے، جو کسی بھی غلطی کو بھی پرنٹ کرتا ہے جو اسے واپس کرتا ہے۔
آؤٹ پٹ
نتیجہ
سافٹ ویئر ڈویلپمنٹ میں شامل ہونا ضروری ہے۔ اغلاط کی درستگی ، اور گولانگ میں بہت سے بلٹ ان فنکشنز اور طریقے ہیں جو اسے احسن طریقے سے کرنے کے لیے ہیں۔ یہ میکانزم ڈویلپرز کو غلطیوں کو پکڑنے اور ان سے بازیافت کرنے، پروگرام کے کریشوں کو روکنے اور اختتامی صارفین کو معلوماتی غلطی کے پیغامات فراہم کرنے کی اجازت دیتے ہیں۔ ان غلطیوں سے نمٹنے کے طریقہ کار کو مؤثر طریقے سے استعمال کرتے ہوئے، ڈویلپرز مضبوط، قابل اعتماد، اور موثر سافٹ ویئر ایپلی کیشنز بنا سکتے ہیں۔