المعالجة العودية لوقت البدء والحكم النهائي في التحقق من صحة النموذج

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

مقارنة الدالة (البدء، النهاية، الخطأ) {
var begin = parseInt(begin,10);
var end = parseInt(end,10);
var diff = end - begin;
إذا (فرق <0) {
تنبيه (خطأ)؛
}آخر{
عودة صحيحة؛
}
}

بهذه الطريقة، أثناء التحقق، طالما كانت النتيجة صحيحة، فهذا يعني أنه تم تمريرها. يحب:

فار سنة = قارن(2001,2003,'السنة');
فار الشهر = قارن(1,2,'الشهر');
فار داي = قارن(12,13,'day');
تنبيه (سنة && شهر && يوم)؛ // النتيجة صحيحة -------"صحيح"

قم بتعديل أشهر البداية والنهاية وتاريخي البدء والانتهاء أعلاه. يحب:

فار سنة = قارن(2001,2003,'السنة');
فار الشهر = قارن(3,2,'الشهر');
فار يوم = قارن(24,13,'يوم');
تنبيه (السنة && الشهر && اليوم / النتيجة خاطئة -------"خطأ")؛

تعرض نتيجة التنفيذ "الشهر" و"اليوم" و"خطأ" بالتسلسل. في الواقع، عندما تكون أشهر البداية والنهاية غير صحيحة، لا نحتاج إلى التحقق من التاريخ؛ فالشرط الأساسي للتحقق من الشهر هو التحقق من السنة يمر الشرط الأساسي للتحقق من اليوم يتم التحقق من الشهر. بعد التحليل الدقيق، قررت تخزين المعلمات الثلاثة للوظيفة المذكورة أعلاه في الوضع الفردي، وهي:

{
البداية: 2001،
النهاية:2003،
خطأ: "يجب أن تكون سنة النهاية أكبر من سنة البداية"
}

ومع ذلك، لا أريد تحديد معلمات الوظيفة. هل يمكن للوظيفة التحقق تلقائيًا بناءً على المعلمات التي تم تمريرها؟ الجواب هو نعم. في بداية الوظيفة، حدد أولاً عدد المعلمات إذا كانت أكبر من 1، فهي تحتوي على معالجة متكررة. كيفية القيام بالمعالجة العودية؟ فعلت ما يلي داخل الوظيفة:

فار لين = الوسيطات. الطول؛
إذا (لين > 1){
var args = Array.prototype.slice.call(arguments);
args.shift(); // قم بإزالة المعلمة الأولى واستخدم المعلمات المتبقية للمعالجة العودية
}

بالنسبة للوسيطات، لا يمكننا استدعاء الأسلوب Array.shift() مباشرة. على الرغم من أن الوسائط لها خاصية الطول، إلا أنها ليست مصفوفة على أي حال، لذا استخدم طريقة Array.slice() لتحويلها إلى مصفوفة. فيما يتعلق بالحجج، يمكنك معرفة المزيد من المعلومات عبر الإنترنت ولن تدخل في التفاصيل هنا. لماذا تتم معالجته فقط عندما يكون لين أكبر من 1؟ لأنه عندما تكون المعلمة 1، ليست هناك حاجة لتنفيذ الخطوة التالية من التحقق. متى تحدث المعالجة العودية؟ إذا فكرت في الأمر بعناية، فلن تكون هناك حاجة إليه إلا عندما تكون القيمة الأولية والقيمة النهائية متساويتين. وبفهم ذلك، يمكننا بسهولة إنشاء وظيفة التحقق الخاصة بنا.

var diff = parseInt(arguments[0].end,10) - parseInt(arguments[0].begin,10);
إذا (فرق <0) {
تنبيه(الوسائط[0].خطأ);
عودة كاذبة.
}إلا إذا (فرق == 0){
إرجاع لين > 1؟
}آخر{
عودة صحيحة؛
}

في الكود أعلاه، الوسيطات.callee هي الوظيفة نفسها. فيما يتعلق باستخدام التطبيق، يمكنك العثور على المعلومات ذات الصلة على الويب.

في هذه المرحلة، تكون وظيفة التحقق قد اكتملت، ولكن عليك الانتباه إلى ما يلي:

1. على الرغم من عدم تحديد عدد المعلمات، إلا أن ترتيب المعلمات لا يزال مهمًا، لأن نتيجة التحقق من المعلمة السابقة تحدد ما إذا كان التحقق من المعلمة التالية سيستمر أم لا؛
2. لا تتجاهل المعلمة الثانية 10 للدالة parseInt(). إذا تم التجاهل، عند مواجهة قيمة تبدأ بـ 0 (مثل 07، 08)، فستتم معالجتها بالنظام الثماني.

هذا كل ما لدينا الآن، دعونا نلقي نظرة على الأمثلة . في بعض الأحيان، لا نرغب في عرض معلومات الخطأ في شكل تنبيه. يمكننا تخصيص وظيفة المعالجة وتمريرها كمعلمة أخيرة. ثم في بداية الوظيفة، احصل على وظيفة المعالجة، مثل:

var func = الوسيطات[len - 1];
إذا (نوع الوظيفة == 'وظيفة'){
func(arguments[0]);
}

وبالتالي فإن وظيفة المعالجة النهائية هي كما يلي:

مقارنة الدالة (){
فار لين = الوسيطات. الطول؛
var func = الوسيطات[len - 1];
إذا (لين > 1){
var args = Array.prototype.slice.call(arguments);
args.shift(); // قم بإزالة المعلمة الأولى واستخدم المعلمات المتبقية للمعالجة العودية
}
var diff = parseInt(arguments[0].end,10) - parseInt(arguments[0].begin,10);
إذا (فرق <0) {
(typeof func == 'function') ? func(arguments[0].error) : تنبيه(arguments[0].error);
عودة كاذبة.
}إلا إذا (فرق == 0){
إرجاع لين > 1؟
}آخر{
عودة صحيحة؛
}
}

مقارنة الدالة (){
فار لين = الوسيطات. الطول؛
إذا (لين > 1){
var args = Array.prototype.slice.call(arguments);
args.shift(); // قم بإزالة المعلمة الأولى واستخدم المعلمات المتبقية للمعالجة العودية

}
var diff = parseInt(arguments[0].end,10) - parseInt(arguments[0].begin,10);
إذا (فرق <0) {
تنبيه(الوسائط[0].خطأ);
عودة كاذبة.
}إلا إذا (فرق == 0){
إرجاع لين > 1؟
}آخر{
عودة صحيحة؛
}
}