دليل التعامل مع الأخطاء في JavaScript باستخدام try/catch

Updated يونيو 12, 2026 7 min read

Aldawsari

دقائق القراءة: 7

مقدمة: لماذا تُعد معالجة الأخطاء جزءاً أساسياً من تطوير البرمجيات؟

الأخطاء البرمجية ليست أمراً استثنائياً، بل هي جزء طبيعي من عملية التطوير. قد يكون الخطأ بسيطاً مثل فاصلة مفقودة، أو أكثر تعقيداً مثل استدعاء متغير غير معرّف. وفي جميع الحالات، فإن الطريقة التي تتعامل بها مع هذه الأخطاء تؤثر مباشرة في جودة التطبيق وتجربة المستخدم.

في JavaScript، تُعد بنية try/catch من أهم الأدوات المخصصة لمعالجة الأخطاء أثناء التشغيل، إذ تساعدك على منع توقف البرنامج بالكامل عند حدوث مشكلة متوقعة، كما تمنحك القدرة على عرض رسائل واضحة أو تنفيذ منطق بديل عند وقوع الخطأ.

شرح معالجة الأخطاء في جافاسكربت باستخدام try catch مع مثال برمجي عملي

ما هي بنية `try/catch` في `JavaScript`؟

تُستخدم try/catch لمعالجة الأخطاء التي قد تظهر أثناء تنفيذ الشيفرة. الفكرة بسيطة: تضع الشيفرة المعرضة للمشكلات داخل كتلة try، وإذا حدث خطأ أثناء التشغيل، تنتقل السيطرة مباشرة إلى كتلة catch للتعامل معه بدلاً من انهيار التنفيذ بالكامل.

try {
  // ...
} catch (e) {
  // ...
}

كتلة try تسمح باختبار الشيفرة، أما كتلة catch فتستقبل كائن الخطأ لمعالجته أو عرض تفاصيله.

مثال عملي بسيط

try {
  getData(); // getData is not defined
} catch (e) {
  alert(e);
}

في المثال السابق، ستفشل الشيفرة لأن الدالة getData() غير معرّفة. وبدلاً من توقف البرنامج بصمت أو انهياره، يتم التقاط الخطأ داخل catch وإظهاره للمستخدم أو للمطور.

ما الذي يحتويه كائن الخطأ في `JavaScript`؟

عند وقوع خطأ، لا تُرجع JavaScript نصاً عادياً فقط، بل كائناً يحمل معلومات مفيدة. من أبرز الخصائص التي يمكنك الاستفادة منها:

name: اسم الخطأ مثل ReferenceError أو TypeError.
message: الرسالة التوضيحية المرتبطة بالخطأ.

لذلك يمكنك التعامل مع الخطأ بمرونة أكبر:

try {
  getData();
} catch (e) {
  console.log(e.name);
  console.log(e.message);
}

هذا الأسلوب مفيد جداً عندما تريد تمييز نوع الخطأ بدقة، أو تسجيله في السجل البرمجي log لأغراض التتبع والتحليل.

لماذا نستخدم `try/catch` بدلاً من الشروط التقليدية؟

قد يظن بعض المطورين أن استخدام if/else يكفي للتحقق من المشكلات، لكن الحقيقة أن try/catch مخصصة لحالات لا يمكن التنبؤ بها دائماً قبل التنفيذ. كما أنها مناسبة لالتقاط الاستثناءات exceptions التي تنتج عن البيئة أو عن تنفيذ تعليمات غير سليمة أثناء التشغيل.

باختصار، الشروط تفحص الحالات المتوقعة، أما try/catch فتتعامل مع الأخطاء الفعلية عند وقوعها.

استخدام `throw` لإنشاء أخطاء مخصصة

من أهم مزايا try/catch أنك لست مضطراً للاعتماد فقط على رسائل الأخطاء الافتراضية. يمكنك إنشاء خطأ مخصص باستخدام الكلمة المفتاحية throw، وهذا يمنحك تحكماً أكبر في الرسائل التي تظهر للمستخدم أو المطور.

let num = prompt("insert a number greater than 30 but less than 40");

try {
  if (isNaN(num)) throw "Not a number (☉｡☉)!";
  else if (num > 40) throw "Did you even read the instructions ಠ︵ಠ, less than 40";
  else if (num <= 30) throw "Greater than 30 (ب_ب)";
} catch (e) {
  alert(e);
}

في هذا المثال، يتم التحقق من قيمة الإدخال، وعند مخالفة الشروط يُرمى خطأ مخصص باستخدام throw. ويمكن أن يكون هذا الخطأ نصاً أو قيمة منطقية أو كائناً.

لماذا يُعد `throw` مهماً؟

يسمح لك بكتابة رسائل مفهومة ومحددة.
يجعل تجربة المستخدم أوضح عند إدخال بيانات غير صحيحة.
يساعد في بناء منطق تحقق أكثر احترافية داخل التطبيقات.

أنواع الأخطاء الشائعة في `JavaScript`

تتضمن JavaScript عدة أنواع من الأخطاء الجاهزة التي تساعد في توصيف المشكلة بدقة. من أبرزها:

EvalError: خطأ متعلق بالدالة eval().
RangeError: يحدث عند استخدام رقم خارج النطاق المقبول.
ReferenceError: عند استخدام متغير غير معرّف.
SyntaxError: عند وجود خطأ في صياغة الشيفرة.
TypeError: عند استخدام قيمة بنوع غير متوقع.
URIError: عند تمرير قيمة غير صحيحة إلى دوال معالجة URI.

أمثلة سريعة

1..toPrecision(500);   // RangeError
(1).toUpperCase();    // TypeError

من المفيد فهم هذه الأنواع لأنك قد تحتاج إلى إنشاء خطأ من نوع محدد أو التحقق من نوعه لاحقاً داخل catch.

إنشاء كائن خطأ عبر `Error`

بدلاً من رمي نص عادي، يمكنك استخدام الباني Error لإنشاء خطأ أكثر تنظيماً:

throw new Error("Hi there");

عندها سيكون اسم الخطأ هو Error، وستكون الرسالة هي Hi there. هذا الأسلوب أفضل من رمي نصوص عشوائية، لأنه ينسجم مع آلية الأخطاء في اللغة.

إنشاء خطأ مخصص خاص بك

function CustomError(message) {
  this.value = "customError";
  this.message = message;
}

ويمكن استخدامه بالشكل التالي:

throw new CustomError("data is not defined");

هذا يفيدك عندما يكون لديك منطق أعمال business logic يحتاج إلى تصنيف أخطاء مخصصة بحسب سياق التطبيق.

متى لا تعمل `try/catch` كما تتوقع؟

رغم أهمية try/catch، فإنها لا تعالج جميع أنواع الأخطاء. وهنا يجب التفريق بين نوعين رئيسيين:

أخطاء وقت التحليل parse-time errors.
أخطاء وقت التشغيل runtime errors.

أخطاء وقت التحليل

هذه الأخطاء تحدث عندما تكون الشيفرة نفسها غير مفهومة للمحرك. في هذه الحالة، لن يبدأ التنفيذ أصلاً، وبالتالي لن تتمكن try/catch من اعتراض المشكلة.

try {
  console.log({{}})
} catch (e) {
  alert(e.message)
}

console.log("This should run after the logged details");

الشيفرة السابقة تحتوي على صياغة غير صحيحة، لذلك لن تنجح try/catch في التعامل معها.

أخطاء وقت التشغيل

هذا النوع يحدث داخل شيفرة صحيحة من حيث الصياغة، لكنه يفشل أثناء التنفيذ. وهنا تظهر فائدة try/catch الحقيقية.

try {
  y = x + 7;
} catch (e) {
  alert("x is not defined");
}

alert("No need to worry, try catch will handle this to prevent your code from breaking");

هذه الشيفرة صحيحة تركيبياً، لكن تنفيذها يؤدي إلى خطأ لأن x غير معرّف. ولهذا تستطيع catch التعامل معه بنجاح.

دور `finally` في معالجة الأخطاء

تأتي كتلة finally لتنفذ الشيفرة بغض النظر عما إذا حدث خطأ أم لا. بمعنى آخر، سواء نجحت كتلة try أو فشلت وانتقلت إلى catch، فإن الأوامر داخل finally ستُنفذ في جميع الأحوال.

let data = prompt("name");

try {
  if (data === "") throw new Error("data is empty");
  else alert(`Hi ${data} how do you do today`);
} catch (e) {
  alert(e);
} finally {
  alert("welcome to the try catch article");
}

أين تُستخدم `finally` عملياً؟

لإغلاق الاتصال بعد انتهاء العملية.
لإخفاء مؤشرات التحميل loading indicators.
لتنظيف الموارد أو إعادة تعيين الحالة.

وجود finally يجعل تدفق البرنامج أكثر موثوقية، خصوصاً في التطبيقات التفاعلية.

فهم تداخل كتل `try` و`catch`

يمكنك كتابة كتلة try داخل كتلة أخرى، لكن هذا الأسلوب قد يجعل الشيفرة أقل وضوحاً إذا أُفرط في استخدامه. مع ذلك، من المهم فهم سلوكه.

try {
  try {
    throw new Error('oops');
  } catch (e) {
    console.log(e);
  } finally {
    console.log('finally');
  }
} catch (ex) {
  console.log('outer ' + ex);
}

في هذا المثال، تتم معالجة الخطأ داخل الكتلة الداخلية نفسها، لذلك لا تنتقل المشكلة إلى catch الخارجية.

ماذا لو لم توجد `catch` داخلية؟

try {
  try {
    throw new Error('inner catch error');
  } finally {
    console.log('finally');
  }
} catch (ex) {
  console.log(ex);
}

هنا لا توجد catch داخلية، لذلك ينتقل الخطأ إلى الكتلة الخارجية، لكن finally الداخلية ستعمل أولاً على أي حال.

مثال يوضح أولوية الخطأ الداخلي

try {
  try {
    throw new Error('inner catch error');
  } catch (e) {
    // comment this catch out
    console.log(e);
  } finally {
    console.log('finally');
  }

  throw new Error("outer catch error");
} catch (ex) {
  console.log(ex);
}

إذا التقطت الكتلة الداخلية خطأها بنفسها، يمكن أن يستمر التنفيذ حتى يصل إلى الخطأ الخارجي. أما إذا أزلت catch الداخلية، فسوف ينتقل الخطأ الداخلي مباشرة إلى catch الخارجية.

إعادة رمي الخطأ باستخدام `Rethrow`

أحياناً لا تريد من catch أن تعالج كل الأخطاء، بل تريد اعتراض نوع محدد فقط، وترك الأنواع الأخرى لتنتقل إلى مستوى أعلى أو توقف التنفيذ. هنا يأتي مفهوم إعادة الرمي أو rethrow.

"use strict";
let x = parseInt(prompt("input a number less than 5"));

try {
  y = x - 10;
  if (y >= 5) throw new Error("y is not less than 5");
  else alert(y);
} catch (e) {
  alert(e);
}

في الوضع الصارم strict mode، سيؤدي استخدام المتغير y دون تعريف إلى ظهور خطأ من نوع ReferenceError. لكن قد يكون هدفك الحقيقي هو التعامل فقط مع الخطأ المنطقي المتعلق بقيمة y.

في هذه الحالة، يمكنك فحص نوع الخطأ وإعادة رميه إن لم يكن من النوع المطلوب:

"use strict";
let x = parseInt(prompt("input a number less than 5"));

try {
  y = x - 10;
  if (y >= 5) throw new Error("y is not less than 5");
  else alert(y);
} catch (e) {
  if (e instanceof ReferenceError) {
    throw e;
  } else {
    alert(e);
  }
}

متى يكون `rethrow` مفيداً؟

عندما تريد معالجة خطأ محدد فقط.
عندما ترغب في تجاهل الأخطاء الناتجة عن أخطاء برمجية جسيمة.
عندما تبني طبقات متعددة من المعالجة داخل التطبيق.

أفضل الممارسات عند استخدام `try/catch` في `JavaScript`

لا تستخدم try/catch لإخفاء الأخطاء البرمجية دون إصلاحها.
احرص على كتابة رسائل واضحة عند استخدام throw.
ميّز بين أخطاء المستخدم وأخطاء المطور.
استخدم finally عند الحاجة إلى تنفيذ عمليات تنظيف مضمونة.
تجنب التداخل المفرط في كتل try لأنه يضعف قابلية القراءة.
اعتمد على أنواع الأخطاء مثل ReferenceError وTypeError لاتخاذ قرارات أدق.

ملخص أهم المفاهيم

تُستخدم try/catch لمعالجة أخطاء وقت التشغيل.
يمكنك إنشاء أخطاء مخصصة عبر throw.
تساعدك Error على بناء أخطاء أكثر تنظيماً.
تعمل finally دائماً سواء حدث خطأ أم لا.
يمكن تمرير الخطأ إلى مستوى أعلى باستخدام rethrow.
لا تستطيع try/catch التعامل مع أخطاء الصياغة التي تمنع المحرك من فهم الشيفرة.

الخلاصة التقنية

تُعد try/catch من الأدوات الجوهرية في JavaScript لبناء تطبيقات أكثر استقراراً واحترافية. قوتها الحقيقية لا تكمن فقط في منع انهيار الشيفرة، بل في تمكينك من إدارة الأخطاء بوعي: متى تلتقطها، ومتى تعيد رميها، ومتى تستخدم finally لضمان اكتمال العمليات المساندة. إذا استُخدمت هذه البنية بشكل صحيح، فإنها ترفع جودة الشيفرة، وتحسن تجربة المستخدم، وتمنحك رؤية أوضح لسلوك التطبيق عند حدوث المشكلات.

مقدمة: لماذا تُعد معالجة الأخطاء جزءاً أساسياً من تطوير البرمجيات؟

ما هي بنية try/catch في JavaScript؟

مثال عملي بسيط

ما الذي يحتويه كائن الخطأ في JavaScript؟

لماذا نستخدم try/catch بدلاً من الشروط التقليدية؟

استخدام throw لإنشاء أخطاء مخصصة

لماذا يُعد throw مهماً؟

أنواع الأخطاء الشائعة في JavaScript

أمثلة سريعة

إنشاء كائن خطأ عبر Error