Error Handling — غلطی سنبھالنا

Robust programs anticipate and handle failures gracefully. The Urdu Programming Language provides کوشش/پکڑو/آخر blocks, a پھینکو statement, built-in error types, and support for custom error classes.

اردو: مضبوط پروگرام ناکامیوں کا پہلے سے اندازہ لگا کر انہیں سلیقے سے سنبھالتے ہیں۔ اردو پروگرامنگ لینگویج کوشش/پکڑو/آخر بلاکس، پھینکو بیان، بنا بنایا غلطی کی اقسام، اور کسٹم غلطی کلاسز کی حمایت فراہم کرتی ہے۔

---

Table of Contents

1. کوشش / پکڑو / آخر — try / catch / finally
2. پھینکو — throw
3. Built-in Error Types
4. Error Properties
5. Custom Error Classes
6. Re-throwing Errors
7. Nested try/catch
8. Async Error Handling
9. Global Error Handling
10. Practical Patterns

---

کوشش / پکڑو / آخر

Syntax:

اردو: نحو:

کوشش {
    // code that might throw
} پکڑو (غلطی) {
    // handle the error
} آخر {
    // always runs — cleanup
}

Basic example:

اردو: بنیادی مثال:

کوشش {
    مستقل نتیجہ = 10 / 2;    // normal computation
    لکھو(نتیجہ);              // 5
    پھینکو نیا Error("کچھ غلط ہوا");
} پکڑو (غ) {
    لکھو(`غلطی پکڑی: ${غ.message}`);
} آخر {
    لکھو("یہ ہمیشہ چلتا ہے");
}
// 5
// غلطی پکڑی: کچھ غلط ہوا
// یہ ہمیشہ چلتا ہے

Only catch (no finally):

اردو: صرف پکڑو (بغیر آخر کے):

کوشش {
    مستقل ڈیٹا = JSON_پڑھو("{بد شکل JSON}");
} پکڑو (غ) {
    لکھو(`JSON غلطی: ${غ.message}`);
}

Only finally (no catch):

اردو: صرف آخر (بغیر پکڑو کے):

متغیر رابطہ = خالی;
کوشش {
    رابطہ = نیا ڈیٹا_بیس();
    رابطہ.چلاؤ("SELECT * FROM users");
} آخر {
    اگر (رابطہ) رابطہ.بند_کرو();    // always close connection
}

The finally block always runs — even after return:

اردو: آخر بلاک ہمیشہ چلتا ہے — واپسی کے بعد بھی:

فنکشن محفوظ_تقسیم(الف, ب) {
    کوشش {
        اگر (ب === 0) پھینکو نیا Error("صفر سے تقسیم");
        واپس الف / ب;
    } پکڑو (غ) {
        لکھو(`غلطی: ${غ.message}`);
        واپس خالی;
    } آخر {
        لکھو("تقسیم آپریشن مکمل");    // runs even when returning
    }
}

لکھو(محفوظ_تقسیم(10, 2));
// تقسیم آپریشن مکمل
// 5

لکھو(محفوظ_تقسیم(10, 0));
// غلطی: صفر سے تقسیم
// تقسیم آپریشن مکمل
// null

---

پھینکو — throw

پھینکو throws any value as an error and immediately exits the current code block.

اردو: پھینکو کسی بھی قدر کو بطور غلطی پھینکتا ہے اور فوری طور پر موجودہ کوڈ بلاک سے نکل جاتا ہے۔

Throw a string:

اردو: سٹرنگ پھینکنا:

فنکشن جانچو(عمر) {
    اگر (عمر < 0) پھینکو "عمر منفی نہیں ہو سکتی";
    اگر (عمر > 150) پھینکو "عمر حد سے زیادہ ہے";
    واپس `عمر ${عمر} قابل قبول ہے`;
}

کوشش {
    لکھو(جانچو(-5));
} پکڑو (غ) {
    لکھو(غ);    // عمر منفی نہیں ہو سکتی
}

Throw an Error object (recommended):

اردو: غلطی شے پھینکنا (تجویز کردہ):

فنکشن فائل_پڑھو(راستہ) {
    اگر (!راستہ) {
        پھینکو نیا TypeError("راستہ درکار ہے");
    }
    اگر (!راستہ.ختم_ہے(".txt")) {
        پھینکو نیا Error(`غیر معاون فائل: ${راستہ}`);
    }
    // ... read file
}

Throw an object:

اردو: شے پھینکنا:

فنکشن API_درخواست(url) {
    اگر (!url.شروع_ہے("https")) {
        پھینکو {
            کوڈ: 400,
            پیغام: "محفوظ HTTPS درکار ہے",
            url
        };
    }
}

کوشش {
    API_درخواست("http://example.com");
} پکڑو (غ) {
    لکھو(غ.کوڈ);     // 400
    لکھو(غ.پیغام);    // محفوظ HTTPS درکار ہے
}

---

Built-in Error Types — بنا بنایا غلطی کی اقسام

Urdu name	JS equivalent	When used
غلطی	Error	Generic errors
قسم_غلطی	TypeError	Wrong type passed or used
حد_غلطی	RangeError	Value out of valid range
حوالہ_غلطی	ReferenceError	Variable not defined
نحو_غلطی	SyntaxError	Invalid syntax (parse time)
رینج_غلطی	RangeError	Numeric range exceeded
نیٹ_غلطی	NetworkError	Network / fetch failure
فائل_غلطی	FileError	File I/O failure

اردو: یہ بنا بنایا غلطی کی اقسام ہیں جو زبان میں پہلے سے موجود ہیں اور مختلف قسم کی غلطیوں کے لیے استعمال ہوتی ہیں۔

// TypeError
کوشش {
    مستقل n = خالی;
    n.toString();
} پکڑو (غ) {
    لکھو(غ مثال TypeError);    // true
    لکھو(غ.message);
}

// RangeError
کوشش {
    نیا Array(-1);
} پکڑو (غ) {
    لکھو(غ مثال RangeError);   // true
}

// ReferenceError
کوشش {
    لکھو(ناموجود_متغیر);
} پکڑو (غ) {
    لکھو(غ مثال ReferenceError);   // true
}

// Throwing specific types
فنکشن رنگ_جانچو(قدر) {
    اگر (قسم(قدر) !== "عدد") {
        پھینکو نیا TypeError(`عدد درکار ہے، ملا: ${قسم(قدر)}`);
    }
    اگر (قدر < 0 یا قدر > 255) {
        پھینکو نیا RangeError(`RGB قدر 0-255 کے درمیان ہونی چاہیے، ملی: ${قدر}`);
    }
    واپس قدر;
}

کوشش { رنگ_جانچو("سرخ"); } پکڑو (غ) { لکھو(غ.name + ": " + غ.message); }
// TypeError: عدد درکار ہے، ملا: متن

کوشش { رنگ_جانچو(300); } پکڑو (غ) { لکھو(غ.name + ": " + غ.message); }
// RangeError: RGB قدر 0-255 کے درمیان ہونی چاہیے، ملی: 300

---

Error Properties — غلطی کی خاصیات

All Error objects share these standard properties:

اردو: تمام غلطی اشیاء میں یہ معیاری خاصیات مشترک ہیں:

Property	Type	Description
message	string	Human-readable description
name	string	Error type name (e.g. "TypeError")
stack	string	Stack trace

مستقل غ = نیا Error("یہ ایک غلطی ہے");
لکھو(غ.name);      // Error
لکھو(غ.message);   // یہ ایک غلطی ہے
لکھو(غ.stack);     // Error: یہ ایک غلطی ہے\n  at ...

مستقل قغ = نیا TypeError("غلط قسم");
لکھو(قغ.name);     // TypeError

---

Custom Error Classes — کسٹم غلطی کلاسز

Extend غلطی (Error) to create domain-specific error types.

اردو: مخصوص شعبے کی غلطی اقسام بنانے کے لیے غلطی (Error) کو وراثت میں لیں۔

کلاس توثیق_غلطی توسیع Error {
    تعمیر(میدان, پیغام) {
        سپر(پیغام);
        یہ.name = "توثیق_غلطی";
        یہ.میدان = میدان;
    }
}

کلاس HTTP_غلطی توسیع Error {
    تعمیر(کوڈ, پیغام) {
        سپر(پیغام);
        یہ.name = "HTTP_غلطی";
        یہ.کوڈ = کوڈ;
    }

    حاصل_کرو مل_گیا_نہیں() {
        واپس یہ.کوڈ === 404;
    }

    حاصل_کرو سرور_غلطی() {
        واپس یہ.کوڈ >= 500;
    }
}

کلاس ڈیٹا_بیس_غلطی توسیع Error {
    تعمیر(سوال, اصل_غلطی) {
        سپر(`سوال ناکام: ${سوال}`);
        یہ.name = "ڈیٹا_بیس_غلطی";
        یہ.سوال = سوال;
        یہ.اصل = اصل_غلطی;
    }
}

// Using custom errors
فنکشن فارم_جانچو(ڈیٹا) {
    اگر (!ڈیٹا.نام یا ڈیٹا.نام.لمبائی < 2) {
        پھینکو نیا توثیق_غلطی("نام", "نام کم از کم 2 حروف کا ہونا چاہیے");
    }
    اگر (!ڈیٹا.ای_میل یا !ڈیٹا.ای_میل.شامل_ہے("@")) {
        پھینکو نیا توثیق_غلطی("ای_میل", "ای میل درست نہیں");
    }
    اگر (!ڈیٹا.عمر یا ڈیٹا.عمر < 18) {
        پھینکو نیا توثیق_غلطی("عمر", "کم از کم عمر 18 سال ہے");
    }
}

کوشش {
    فارم_جانچو({ نام: "ا", ای_میل: "بدشکل", عمر: 16 });
} پکڑو (غ) {
    اگر (غ مثال توثیق_غلطی) {
        لکھو(`توثیق ناکام — ${غ.میدان}: ${غ.message}`);
    } ورنہ {
        پھینکو غ;    // re-throw unexpected errors
    }
}
// توثیق ناکام — نام: نام کم از کم 2 حروف کا ہونا چاہیے

// Catching by type
غیر_متزامن فنکشن API_کال(url) {
    کوشش {
        مستقل جواب = انتظار کرل(url);
        اگر (!جواب.ok) {
            پھینکو نیا HTTP_غلطی(جواب.status, جواب.statusText);
        }
        واپس انتظار جواب.json();
    } پکڑو (غ) {
        اگر (غ مثال HTTP_غلطی) {
            اگر (غ.مل_گیا_نہیں) {
                لکھو("وسیلہ نہیں ملا");
            } ورنہ_اگر (غ.سرور_غلطی) {
                لکھو("سرور مسئلہ — بعد میں کوشش کریں");
            }
        } ورنہ_اگر (غ مثال TypeError) {
            لکھو("نیٹ ورک سے رابطہ نہیں");
        } ورنہ {
            پھینکو غ;
        }
        واپس خالی;
    }
}

---

Re-throwing Errors — غلطیاں دوبارہ پھینکنا

Catch only the errors you can handle; re-throw the rest.

اردو: صرف وہ غلطیاں پکڑیں جنہیں آپ سنبھال سکتے ہیں؛ باقی کو دوبارہ پھینک دیں۔

فنکشن ڈیٹا_پارس_کرو(متن_شے) {
    کوشش {
        واپس JSON_پڑھو(متن_شے);
    } پکڑو (غ) {
        // Only handle SyntaxError from JSON parsing
        اگر (غ مثال SyntaxError) {
            پھینکو نیا Error(`JSON پارس ناکام: ${غ.message}`);
        }
        پھینکو غ;    // re-throw other errors unchanged
    }
}

// Enriching and re-throwing
غیر_متزامن فنکشن صارف_بنائیں(ڈیٹا) {
    کوشش {
        فارم_جانچو(ڈیٹا);
        واپس انتظار ڈیٹا_بیس.داخل_کرو("users", ڈیٹا);
    } پکڑو (غ) {
        // Add context and re-throw
        غ.سیاق = "صارف بنانے کے دوران";
        پھینکو غ;
    }
}

کوشش {
    انتظار صارف_بنائیں({ نام: "" });
} پکڑو (غ) {
    لکھو(`${غ.سیاق}: ${غ.message}`);
    // صارف بنانے کے دوران: نام کم از کم 2 حروف کا ہونا چاہیے
}

---

Nested try/catch — گھونسلے دار کوشش/پکڑو

Inner catches handle specific issues; outer catches are broader safety nets.

اردو: اندرونی پکڑو مخصوص مسائل سنبھالتا ہے؛ بیرونی پکڑو وسیع تر حفاظتی جال ہے۔

غیر_متزامن فنکشن رپورٹ_بنائیں(صارف_id) {
    کوشش {
        // Outer: catch all unexpected errors

        مستقل صارف = کوشش {
            انتظار صارف_حاصل_کرو(صارف_id);
        } پکڑو (غ) {
            // Inner: default user if not found
            اگر (غ مثال HTTP_غلطی اور غ.مل_گیا_نہیں) {
                واپس { نام: "مہمان", id: 0 };
            }
            پھینکو غ;
        };

        مستقل ڈیٹا = کوشش {
            انتظار ڈیٹا_حاصل_کرو(صارف_id);
        } پکڑو (غ) {
            // Inner: return empty on data error
            لکھو(`ڈیٹا لوڈ ناکام: ${غ.message}`);
            واپس [];
        };

        واپس { صارف, ڈیٹا };

    } پکڑو (غ) {
        لکھو(`رپورٹ بنانا ناکام: ${غ.message}`);
        واپس خالی;
    }
}

---

Async Error Handling — غیر متزامن غلطی سنبھالنا

See also 08-async.md. Key patterns:

اردو: مزید معلومات کے لیے 08-async.md بھی دیکھیں۔ اہم طریقے:

// Pattern 1: try/catch in async function
غیر_متزامن فنکشن محفوظ_لوڈ(id) {
    کوشش {
        مستقل ڈیٹا = انتظار کرل(`/api/items/${id}`);
        واپس JSON_پڑھو(ڈیٹا);
    } پکڑو (غ) {
        لکھو(`لوڈ ناکام: ${غ.message}`);
        واپس خالی;
    }
}

// Pattern 2: Result tuple [error, data]
غیر_متزامن فنکشن محفوظ(وعدہ_شے) {
    کوشش {
        مستقل ڈیٹا = انتظار وعدہ_شے;
        واپس [خالی, ڈیٹا];
    } پکڑو (غ) {
        واپس [غ, خالی];
    }
}

مستقل [غلطی, صارف] = انتظار محفوظ(صارف_حاصل_کرو(42));
اگر (غلطی) {
    لکھو(`غلطی: ${غلطی.message}`);
} ورنہ {
    لکھو(صارف.نام);
}

// Pattern 3: Error boundary in parallel calls
غیر_متزامن فنکشن تمام_لوڈ(ids) {
    مستقل نتائج = انتظار Promise.allSettled(
        ids.تبدیل(id => صارف_حاصل_کرو(id))
    );

    مستقل کامیاب = نتائج
        .چھانو(r => r.status === "fulfilled")
        .تبدیل(r => r.value);

    مستقل ناکام_ids = نتائج
        .تبدیل((r, i) => [i, r])
        .چھانو(([_, r]) => r.status === "rejected")
        .تبدیل(([i]) => ids[i]);

    اگر (ناکام_ids.لمبائی > 0) {
        لکھو(`ناکام IDs: ${ناکام_ids.جوڑو(", ")}`);
    }

    واپس کامیاب;
}

---

Global Error Handling — عالمی غلطی سنبھالنا

Catch unhandled errors at the program level.

اردو: پروگرام کی سطح پر بغیر پکڑی غلطیاں سنبھالیں۔

// Unhandled promise rejections
process.on("unhandledRejection", (وجہ, وعدہ_شے) => {
    لکھو(`بغیر پکڑی Promise مسترد: ${وجہ}`);
});

// Uncaught exceptions
process.on("uncaughtException", (غ) => {
    لکھو(`بغیر پکڑی غلطی: ${غ.message}`);
    process.exit(1);
});

---

Practical Patterns — عملی طریقے

Safe JSON parse — محفوظ JSON پارس

فنکشن محفوظ_JSON_پڑھو(متن_شے, پہلے_سے_طے = خالی) {
    کوشش {
        واپس JSON_پڑھو(متن_شے);
    } پکڑو {
        واپس پہلے_سے_طے;
    }
}

لکھو(محفوظ_JSON_پڑھو('{"نام":"علی"}'));   // { نام: "علی" }
لکھو(محفوظ_JSON_پڑھو("بد شکل", {}));     // {}

Input validation helper — ان پٹ توثیق مددگار

کلاس جانچ {
    جامد درکار(قدر, میدان) {
        اگر (قدر === خالی یا قدر === غیر_معرف یا قدر === "") {
            پھینکو نیا توثیق_غلطی(میدان, `${میدان} درکار ہے`);
        }
        واپس قدر;
    }

    جامد کم_از_کم(قدر, حد_قدر, میدان) {
        اگر (قدر < حد_قدر) {
            پھینکو نیا توثیق_غلطی(میدان, `${میدان} کم از کم ${حد_قدر} ہونی چاہیے`);
        }
        واپس قدر;
    }

    جامد زیادہ_سے_زیادہ(قدر, حد_قدر, میدان) {
        اگر (قدر > حد_قدر) {
            پھینکو نیا توثیق_غلطی(میدان, `${میدان} زیادہ سے زیادہ ${حد_قدر} ہونی چاہیے`);
        }
        واپس قدر;
    }

    جامد ای_میل(قدر, میدان = "ای_میل") {
        جانچ.درکار(قدر, میدان);
        اگر (!قدر.شامل_ہے("@")) {
            پھینکو نیا توثیق_غلطی(میدان, "ای میل فارمیٹ غلط ہے");
        }
        واپس قدر;
    }
}

کوشش {
    جانچ.درکار("", "نام");
} پکڑو (غ) {
    لکھو(`${غ.میدان}: ${غ.message}`);
    // نام: نام درکار ہے
}

Graceful degradation — بتدریج کمی

اردو: اگر ایک ذریعہ ناکام ہو تو دوسرے پر جائیں:

غیر_متزامن فنکشن ویجٹ_لوڈ() {
    // Try live data, fall back to cache, then default
    کوشش {
        واپس انتظار API.حاصل_کرو("/ویجٹ");
    } پکڑو {
        لکھو("لائیو ڈیٹا ناکام، کیش آزما رہے ہیں...");
    }

    کوشش {
        واپس انتظار کیش.حاصل_کرو("ویجٹ");
    } پکڑو {
        لکھو("کیش بھی ناکام، پہلے سے طے شدہ ڈیٹا استعمال ہو رہا ہے");
    }

    واپس { عنوان: "ڈیٹا دستیاب نہیں", قدریں: [] };
}