valitron

Valitron: التحقق السهل الذي لا يمتص

Valitron عبارة عن مكتبة تحقق مستقلة بسيطة وأنيقة ولا تحتوي على أي تبعيات. يستخدم Valitron طرقًا بسيطة ومباشرة للتحقق من الصحة مع التركيز على بناء الجملة الموجز والقابل للقراءة. Valitron هي مكتبة التحقق البسيطة والعملية التي كنت تبحث عنها.

احصل على دعم vlucas/valitron من خلال اشتراك Tidelift

لماذا فاليترون؟

تم إنشاء Valitron بسبب الإحباط من مكتبات التحقق الأخرى التي تعتمد على مكونات كبيرة من أطر عمل أخرى مثل Symfony's HttpFoundation، مما أدى إلى سحب الكثير من الملفات الإضافية التي ليست هناك حاجة إليها بالفعل للتحقق الأساسي. كما أن لديها بنية بسيطة بشكل مقصود تستخدم لتشغيل جميع عمليات التحقق من الصحة في مكالمة واحدة بدلاً من التحقق من صحة كل قيمة بشكل فردي عن طريق إنشاء فئات جديدة والتحقق من صحة القيم واحدة تلو الأخرى كما تتطلب بعض مكتبات التحقق الأخرى.

باختصار، Valitron هو كل ما كنت تبحث عنه في مكتبة التحقق ولكنك لم تتمكن من العثور عليه حتى الآن: بناء جملة عملي بسيط، رمز خفيف الوزن منطقي، قابل للتوسيع لعمليات الاسترجاعات المخصصة وعمليات التحقق من الصحة، تم اختباره جيدًا، وبدون تبعيات . دعونا نبدأ.

تثبيت

يستخدم Valitron Composer للتثبيت والتحديث:

 curl -s http://getcomposer.org/installer | php
php composer.phar require vlucas/valitron

تستخدم الأمثلة أدناه بناء جملة PHP 5.4، لكن Valitron يعمل على PHP 5.3+.

الاستخدام

الاستخدام بسيط ومباشر. ما عليك سوى توفير مجموعة من البيانات التي ترغب في التحقق من صحتها، وإضافة بعض القواعد، ثم استدعاء validate() . إذا كان هناك أي أخطاء، يمكنك استدعاء errors() للحصول عليها.

 $ v = new Valitron  Validator ( array ( ' name ' => ' Chester Tester ' ));
$ v -> rule ( ' required ' , ' name ' );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

باستخدام هذا التنسيق، يمكنك التحقق من صحة بيانات $_POST مباشرة وسهولة، ويمكنك أيضًا تطبيق القاعدة required على مجموعة من الحقول:

 $ v = new Valitron  Validator ( $ _POST );
$ v -> rule ( ' required ' , [ ' name ' , ' email ' ]);
$ v -> rule ( ' email ' , ' email ' );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

يمكنك استخدام بناء الجملة النقطي للوصول إلى أعضاء المصفوفات متعددة الأبعاد، والعلامة النجمية للتحقق من صحة كل عضو في المصفوفة:

 $ v = new Valitron  Validator ( array ( ' settings ' => array (
    array ( ' threshold ' => 50 ),
    array ( ' threshold ' => 90 )
)));
$ v -> rule ( ' max ' , ' settings.*.threshold ' , 100 );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

أو استخدم بناء الجملة النقطي للتحقق من صحة جميع أعضاء المصفوفة الرقمية:

 $ v = new Valitron  Validator ( array ( ' values ' => array ( 50 , 90 )));
$ v -> rule ( ' max ' , ' values.* ' , 100 );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

يمكنك أيضًا الوصول إلى القيم المتداخلة باستخدام التدوين النقطي:

 $ v = new Valitron  Validator ( array ( ' user ' => array ( ' first_name ' => ' Steve ' , ' last_name ' => ' Smith ' , ' username ' => ' Batman123 ' )));
$ v -> rule ( ' alpha ' , ' user.first_name ' )-> rule ( ' alpha ' , ' user.last_name ' )-> rule ( ' alphaNum ' , ' user.username ' );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

ضبط اللغة واللغة dir عالميًا:

 // boot or config file

use Valitron  Validator as V ;

V:: langDir ( __DIR__ . ' /validator_lang ' ); // always set langDir before lang.
V:: lang ( ' ar ' );

تعطيل اسم {الحقل} في إخراج رسالة الخطأ.

 use Valitron  Validator as V ;

$ v = new Valitron  Validator ([ ' name ' => ' John ' ]);
$ v -> rule ( ' required ' , [ ' name ' ]);

// Disable prepending the labels
$ v -> setPrependLabels ( false );

// Error output for the "false" condition
[
    [ " name " ] => [
        " is required "
    ]
]

// Error output for the default (true) condition
[
    [ " name " ] => [
        " name is required "
    ]
]

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

 // this rule set would work for either data set...
$ data = [ ' email ' => ' [email protected] ' , ' password ' => ' mypassword ' ];
// or...
$ data = [ ' token ' => ' jashdjahs83rufh89y38h38h ' ];

$ v = new Valitron  Validator ( $ data );
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' token ' , [ ' email ' , ' password ' ], true ]
    ],
    ' requiredWith ' => [
        [ ' password ' , [ ' email ' ]]
    ],
    ' email ' => [
        [ ' email ' ]
    ]
    ' optional ' => [
        [ ' email ' ]
    ]
]);
$ this -> assertTrue ( $ v -> validate ());

قواعد التحقق المضمنة

• required - الحقل مطلوب
• requiredWith - الحقل مطلوب في حالة وجود أي حقول أخرى
• requiredWithout - الحقل مطلوب في حالة عدم وجود حقول أخرى
• equals - يجب أن يتطابق الحقل مع حقل آخر (تأكيد البريد الإلكتروني/كلمة المرور)
• different - يجب أن يكون الحقل مختلفًا عن حقل آخر
• accepted - يجب قبول خانة الاختيار أو الراديو (نعم، في 1، صحيح)
• numeric - يجب أن يكون رقميًا
• integer - يجب أن يكون رقمًا صحيحًا
• boolean - يجب أن تكون منطقية
• array - يجب أن يكون صفيفًا
• length - يجب أن يكون للسلسلة طول معين
• lengthBetween - يجب أن تكون السلسلة بين أطوال معينة
• lengthMin - يجب أن تكون السلسلة أكبر من الطول المحدد
• lengthMax - يجب أن تكون السلسلة أقل من الطول المحدد
• min - الحد الأدنى
• max - الحد الأقصى
• listContains - يقوم بإجراء فحص in_array على قيم المصفوفة المحددة (بطريقة أخرى بدلاً من in )
• in - يقوم بإجراء فحص in_array على قيم المصفوفة المحددة
• notIn - نفي in (وليس في مجموعة من القيم)
• ip - عنوان IP صالح
• ipv4 - عنوان IP v4 صالح
• ipv6 - عنوان IP v6 صالح
• email - عنوان بريد إلكتروني صالح
• emailDNS - عنوان بريد إلكتروني صالح مع سجل DNS نشط
• url - عنوان URL صالح
• urlActive - عنوان URL صالح مع سجل DNS نشط
• alpha - الحروف الأبجدية فقط
• alphaNum - الأحرف الأبجدية والأرقام فقط
• ascii - أحرف ASCII فقط
• slug - أحرف سبيكة URL (az، 0-9، -، _)
• regex - يتطابق الحقل مع نمط regex المحدد
• date - الحقل تاريخ صالح
• dateFormat - الحقل هو تاريخ صالح بالتنسيق المحدد
• dateBefore - الحقل تاريخ صالح ويقع قبل التاريخ المحدد
• dateAfter - الحقل تاريخ صالح ويقع بعد التاريخ المحدد
• contains - الحقل عبارة عن سلسلة ويحتوي على السلسلة المحددة
• subset - الحقل عبارة عن مصفوفة أو عددية وجميع العناصر موجودة في المصفوفة المحددة
• containsUnique - الحقل عبارة عن مصفوفة ويحتوي على قيم فريدة
• creditCard - الحقل عبارة عن رقم بطاقة ائتمان صالح
• instanceOf - يحتوي الحقل على مثيل للفئة المحددة
• optional - لا يلزم تضمين القيمة في صفيف البيانات. إذا كان الأمر كذلك، يجب أن تمر التحقق من الصحة.
• arrayHasKeys - الحقل عبارة عن مصفوفة ويحتوي على كافة المفاتيح المحددة.

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

استخدام الحقول المطلوبة

تتحقق القاعدة required من وجود حقل في مصفوفة البيانات، وأنه ليس فارغًا أو سلسلة فارغة.

 $ v -> rule ( ' required ' , ' field_name ' );

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

 $ v -> rule ( ' required ' , ' field_name ' , true );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' , ' required_but_null ' => null ]);
$ v -> rules ([
    ' required ' => [
        [ ' username ' ],
        [ ' password ' ],
        [ ' required_but_null ' , true ] // boolean flag allows empty value so long as the field name is set on the data array
    ]
]);
$ v -> validate ();

مطلوب مع استخدام الحقول

تتحقق القاعدة requiredWith من أن الحقل مطلوب، وليس فارغًا، وليس سلسلة فارغة، في حالة وجود أي حقول أخرى، وليس فارغًا، وليس سلسلة فارغة.

 // password field will be required when the username field is provided and not empty
$ v -> rule ( ' requiredWith ' , ' password ' , ' username ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' ]);
$ v -> rules ([
    ' requiredWith ' => [
        [ ' password ' , ' username ' ]
    ]
]);
$ v -> validate ();

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

 // in this case the password field will be required if the username or email fields are present
$ v -> rule ( ' requiredWith ' , ' password ' , [ ' username ' , ' email ' ]);

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' ]);
$ v -> rules ([
    ' requiredWith ' => [
        [ ' password ' , [ ' username ' , ' email ' ]]
    ]
]);
$ v -> validate ();

علم صارم

ستغير العلامة الصارمة القاعدة requiredWith إلى requiredWithAll والتي ستتطلب الحقل فقط في حالة وجود جميع الحقول الأخرى، وليست فارغة، وليست سلسلة فارغة.

 // in this example the suffix field is required only when both the first_name and last_name are provided
$ v -> rule ( ' requiredWith ' , ' suffix ' , [ ' first_name ' , ' last_name ' ], true );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' first_name ' => ' steve ' , ' last_name ' => ' holt ' , ' suffix ' => ' Mr ' ]);
$ v -> rules ([
    ' requiredWith ' => [
        [ ' suffix ' , [ ' first_name ' , ' last_name ' ], true ]
    ]
]);
$ v -> validate ();

وبالمثل، في هذه الحالة، ستظل validate() ‎ تُرجع صحيحًا، حيث لن يكون حقل اللاحقة مطلوبًا في الوضع الصارم، حيث لا يتم توفير كافة الحقول.

 $ v = new Valitron  Validator ([ ' first_name ' => ' steve ' ]);
$ v -> rules ([
    ' requiredWith ' => [
        [ ' suffix ' , [ ' first_name ' , ' last_name ' ], true ]
    ]
]);
$ v -> validate ();

مطلوب بدون استخدام الحقول

تتحقق القاعدة requiredWithout من أن الحقل مطلوب، وليس فارغًا، وليس سلسلة فارغة، في حالة عدم وجود أي حقول أخرى.

 // this rule will require the username field when the first_name is not present
$ v -> rule ( ' requiredWithout ' , ' username ' , ' first_name ' )

بناء الجملة البديل.

 // this will return true, as the username is provided when the first_name is not provided
$ v = new Valitron  Validator ([ ' username ' => ' spiderman ' ]);
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' username ' , ' first_name ' ]
    ]
]);
$ v -> validate ();

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

 // in this case the username field will be required if either the first_name or last_name fields are not present
$ v -> rule ( ' requiredWithout ' , ' username ' , [ ' first_name ' , ' last_name ' ]);

بناء الجملة البديل.

 // this passes validation because although the last_name field is not present, the username is provided
$ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' first_name ' => ' Peter ' ]);
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' username ' , [ ' first_name ' , ' last_name ' ]]
    ]
]);
$ v -> validate ();

علم صارم

ستغير العلامة الصارمة قاعدة requiredWithout إلى requiredWithoutAll والتي ستتطلب الحقل فقط في حالة عدم وجود كافة الحقول الأخرى.

 // in this example the username field is required only when both the first_name and last_name are not provided
$ v -> rule ( ' requiredWithout ' , ' username ' , [ ' first_name ' , ' last_name ' ], true );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' BatMan ' ]);
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' username ' , [ ' first_name ' , ' last_name ' ], true ]
    ]
]);
$ v -> validate ();

وبالمثل، في هذه الحالة، ستظل validate() ‎ تُرجع صحيحًا، حيث لن يكون حقل اسم المستخدم مطلوبًا في الوضع الصارم، حيث يتم توفير جميع الحقول.

 $ v = new Valitron  Validator ([ ' first_name ' => ' steve ' , ' last_name ' => ' holt ' ]);
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' suffix ' , [ ' first_name ' , ' last_name ' ], true ]
    ]
]);
$ v -> validate ();

يساوي استخدام الحقول

تتحقق قاعدة equals مما إذا كان هناك حقلان متساويان في صفيف البيانات، وأن الحقل الثاني ليس فارغًا.

 $ v -> rule ( ' equals ' , ' password ' , ' confirmPassword ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' password ' => ' youshouldnotseethis ' , ' confirmPassword ' => ' youshouldnotseethis ' ]);
$ v -> rules ([
    ' equals ' => [
        [ ' password ' , ' confirmPassword ' ]
    ]
]);
$ v -> validate ();

استخدام المجالات المختلفة

تتحقق القاعدة different مما إذا كان الحقلان غير متماثلين أو مختلفين في صفيف البيانات وأن الحقل الثاني ليس فارغًا.

 $ v -> rule ( ' different ' , ' username ' , ' password ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' ]);
$ v -> rules ([
    ' different ' => [
        [ ' username ' , ' password ' ]
    ]
]);
$ v -> validate ();

استخدام الحقول المقبولة

تتحقق القاعدة accepted مما إذا كان الحقل إما "نعم" أو "تشغيل" أو 1 أو صحيح.

 $ v -> rule ( ' accepted ' , ' remember_me ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' remember_me ' => true ]);
$ v -> rules ([
    ' accepted ' => [
        [ ' remember_me ' ]
    ]
]);
$ v -> validate ();

استخدام الحقول الرقمية

تتحقق القاعدة numeric مما إذا كان الحقل رقمًا. هذا مشابه للدالة is_numeric() في PHP.

 $ v -> rule ( ' numeric ' , ' amount ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' amount ' => 3.14 ]);
$ v -> rules ([
    ' numeric ' => [
        [ ' amount ' ]
    ]
]);
$ v -> validate ();

استخدام حقول الأعداد الصحيحة

تتحقق قاعدة integer مما إذا كان الحقل رقمًا صحيحًا.

 $ v -> rule ( ' integer ' , ' age ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' age ' => ' 27 ' ]);
$ v -> rules ([
    ' integer ' => [
        [ ' age ' ]
    ]
]);
$ v -> validate ();

لاحظ أن العلامة المنطقية الاختيارية للوضع الصارم تتأكد من توفير الأعداد الصحيحة في شكل رقمي صارم. لذلك سيتم تقييم القاعدة التالية على أنها صحيحة:

 $ v = new Valitron  Validator ([ ' negative ' => ' -27 ' , ' positive ' => ' 27 ' ]);
$ v -> rule ( ' integer ' , ' age ' , true );
$ v -> rule ( ' integer ' , ' height ' , true );
$ v -> validate ();

حيث سيتم تقييم ما يلي على أنه خطأ، حيث أن + للرقم الموجب في هذه الحالة زائدة عن الحاجة:

 $ v = new Valitron  Validator ([ ' negative ' => ' -27 ' , ' positive ' => ' +27 ' ]);
$ v -> rule ( ' integer ' , ' age ' , true );
$ v -> rule ( ' integer ' , ' height ' , true );
$ v -> validate ();

استخدام الحقول المنطقية

تتحقق القاعدة boolean مما إذا كان الحقل منطقيًا. هذا مشابه لوظيفة is_bool() في PHP.

 $ v -> rule ( ' boolean ' , ' remember_me ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' remember_me ' => true ]);
$ v -> rules ([
    ' boolean ' => [
        [ ' remember_me ' ]
    ]
]);
$ v -> validate ();

استخدام حقول المصفوفة

تتحقق قاعدة array مما إذا كان الحقل عبارة عن صفيف. هذا مشابه لوظيفة is_array() في PHP.

 $ v -> rule ( ' array ' , ' user_notifications ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' user_notifications ' => [ ' bulletin_notifications ' => true , ' marketing_notifications ' => false , ' message_notification ' => true ]]);
$ v -> rules ([
    ' array ' => [
        [ ' user_notifications ' ]
    ]
]);
$ v -> validate ();

استخدام حقول الطول

تتحقق قاعدة length مما إذا كان الحقل بطول معين تمامًا وأن الحقل عبارة عن سلسلة صالحة.

 $ v -> rule ( ' length ' , ' username ' , 10 );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' bobburgers ' ]);
$ v -> rules ([
    ' length ' => [
        [ ' username ' , 10 ]
    ]
]);
$ v -> validate ();

lengthbetween استخدام الحقول

تتحقق قاعدة lengthBetween مما إذا كان الحقل يقع بين نطاق طول معين وأن الحقل عبارة عن سلسلة صالحة.

 $ v -> rule ( ' lengthBetween ' , ' username ' , 1 , 10 );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' bobburgers ' ]);
$ v -> rules ([
    ' lengthBetween ' => [
        [ ' username ' , 1 , 10 ]
    ]
]);
$ v -> validate ();

استخدام حقول lengthMin

تتحقق قاعدة lengthMin مما إذا كان الحقل بطول معين على الأقل وأن الحقل عبارة عن سلسلة صالحة.

 $ v -> rule ( ' lengthMin ' , ' username ' , 5 );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' martha ' ]);
$ v -> rules ([
    ' lengthMin ' => [
        [ ' username ' , 5 ]
    ]
]);
$ v -> validate ();

استخدام حقول lengthMax

تتحقق قاعدة lengthMax مما إذا كان الحقل بطول معين على الأكثر وأن الحقل عبارة عن سلسلة صالحة.

 $ v -> rule ( ' lengthMax ' , ' username ' , 10 );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' bruins91 ' ]);
$ v -> rules ([
    ' lengthMax ' => [
        [ ' username ' , 10 ]
    ]
]);
$ v -> validate ();

الحد الأدنى من استخدام الحقول

تتحقق قاعدة min مما إذا كان الحقل يمثل قيمة معينة على الأقل وأن القيمة المقدمة رقمية.

 $ v -> rule ( ' min ' , ' age ' , 18 );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' age ' => 28 ]);
$ v -> rules ([
    ' min ' => [
        [ ' age ' , 18 ]
    ]
]);
$ v -> validate ();

الحد الأقصى لاستخدام الحقول

تتحقق قاعدة max مما إذا كان الحقل قيمة معينة على الأكثر وأن القيمة المقدمة رقمية.

 $ v -> rule ( ' max ' , ' age ' , 12 );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' age ' => 10 ]);
$ v -> rules ([
    ' max ' => [
        [ ' age ' , 12 ]
    ]
]);
$ v -> validate ();

تحتوي القائمة على استخدام الحقول

تتحقق قاعدة listContains من وجود الحقل في صفيف محدد من القيم.

 $ v -> rule ( ' listContains ' , ' color ' , ' yellow ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' color ' => [ ' blue ' , ' green ' , ' red ' , ' yellow ' ]]);
$ v -> rules ([
    ' listContains ' => [
        [ ' color ' , ' yellow ' ]
    ]
]);
$ v -> validate ();

في مجالات الاستخدام

تتحقق in من وجود الحقل في صفيف محدد من القيم.

 $ v -> rule ( ' in ' , ' color ' , [ ' blue ' , ' green ' , ' red ' , ' purple ' ]);

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' color ' => ' purple ' ]);
$ v -> rules ([
    ' in ' => [
        [ ' color ' , [ ' blue ' , ' green ' , ' red ' , ' purple ' ]]
    ]
]);
$ v -> validate ();

ليس في مجالات الاستخدام

تتحقق قاعدة notIn من عدم وجود الحقل في مصفوفة معينة من القيم.

 $ v -> rule ( ' notIn ' , ' color ' , [ ' blue ' , ' green ' , ' red ' , ' yellow ' ]);

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' color ' => ' purple ' ]);
$ v -> rules ([
    ' notIn ' => [
        [ ' color ' , [ ' blue ' , ' green ' , ' red ' , ' yellow ' ]]
    ]
]);
$ v -> validate ();

استخدام حقول IP

تتحقق قاعدة ip من أن الحقل هو عنوان IP صالح. يتضمن ذلك النطاقات IPv4 وIPv6 والنطاقات الخاصة والمحجوزة.

 $ v -> rule ( ' ip ' , ' user_ip ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' user_ip ' => ' 127.0.0.1 ' ]);
$ v -> rules ([
    ' ip ' => [
        [ ' user_ip ' ]
    ]
]);
$ v -> validate ();

استخدام حقول IPv4

تتحقق قاعدة ipv4 من أن الحقل هو عنوان IPv4 صالح.

 $ v -> rule ( ' ipv4 ' , ' user_ip ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' user_ip ' => ' 127.0.0.1 ' ]);
$ v -> rules ([
    ' ipv4 ' => [
        [ ' user_ip ' ]
    ]
]);
$ v -> validate ();

استخدام حقول IPv6

تتحقق قاعدة ipv6 من أن الحقل هو عنوان IPv6 صالح.

 $ v -> rule ( ' ipv6 ' , ' user_ip ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' user_ip ' => ' 0:0:0:0:0:0:0:1 ' ]);
$ v -> rules ([
    ' ipv6 ' => [
        [ ' user_ip ' ]
    ]
]);
$ v -> validate ();

استخدام حقول البريد الإلكتروني

تتحقق قاعدة email من أن الحقل هو عنوان بريد إلكتروني صالح.

 $ v -> rule ( ' email ' , ' user_email ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' user_email ' => ' [email protected] ' ]);
$ v -> rules ([
    ' email ' => [
        [ ' user_email ' ]
    ]
]);
$ v -> validate ();

استخدام حقول emailDNS

تتحقق قاعدة emailDNS من أن الحقل هو عنوان بريد إلكتروني صالح مع سجل DNS نشط أو أي نوع.

 $ v -> rule ( ' emailDNS ' , ' user_email ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' user_email ' => ' [email protected] ' ]);
$ v -> rules ([
    ' emailDNS ' => [
        [ ' user_email ' ]
    ]
]);
$ v -> validate ();

استخدام حقول URL

تتحقق قاعدة url من أن الحقل هو عنوان url صالح.

 $ v -> rule ( ' url ' , ' website ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' website ' => ' https://example.com/contact ' ]);
$ v -> rules ([
    ' url ' => [
        [ ' website ' ]
    ]
]);
$ v -> validate ();

url استخدام الحقول النشطة

تتحقق قاعدة urlActive من أن الحقل هو عنوان url صالح يحتوي على سجل A أو AAAA أو CNAME نشط.

 $ v -> rule ( ' urlActive ' , ' website ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' website ' => ' https://example.com/contact ' ]);
$ v -> rules ([
    ' urlActive ' => [
        [ ' website ' ]
    ]
]);
$ v -> validate ();

استخدام حقول ألفا

تتحقق قاعدة alpha من أن الحقل يتكون من أحرف أبجدية فقط.

 $ v -> rule ( ' alpha ' , ' username ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' batman ' ]);
$ v -> rules ([
    ' alpha ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

استخدام حقول alphaNum

تتحقق القاعدة alphaNum من أن الحقل يحتوي على أحرف أبجدية أو رقمية فقط.

 $ v -> rule ( ' alphaNum ' , ' username ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' batman123 ' ]);
$ v -> rules ([
    ' alphaNum ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

استخدام حقول ascii

تتحقق قاعدة ascii من أن الحقل يحتوي على أحرف فقط في مجموعة أحرف ascii.

 $ v -> rule ( ' ascii ' , ' username ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' batman123 ' ]);
$ v -> rules ([
    ' ascii ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

استخدام حقول سبيكة

تتحقق القاعدة slug من أن الحقل يحتوي فقط على أحرف ثابتة لعنوان URL (az، 0-9، -، _).

 $ v -> rule ( ' slug ' , ' username ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' L337-H4ckZ0rz_123 ' ]);
$ v -> rules ([
    ' slug ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

استخدام حقول regex

تضمن قاعدة regex أن يتطابق الحقل مع نمط regex محدد. (يتحقق هذا التعبير العادي من أن السلسلة تحتوي على أرقام أبجدية تتراوح بين 5 إلى 10 أحرف).

 $ v -> rule ( ' regex ' , ' username ' , ' /^[a-zA-Z0-9]{5,10}$/ ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
    ' regex ' => [
        [ ' username ' , ' /^[a-zA-Z0-9]{5,10}$/ ' ]
    ]
]);
$ v -> validate ();

استخدام حقول التاريخ

تتحقق قاعدة date مما إذا كان الحقل المقدم هو كائن DateTime صالح أو ما إذا كان من الممكن تحويل السلسلة إلى طابع زمني يونكس عبر strtotime().

 $ v -> rule ( ' date ' , ' created_at ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' created_at ' => ' 2018-10-13 ' ]);
$ v -> rules ([
    ' date ' => [
        [ ' created_at ' ]
    ]
]);
$ v -> validate ();

استخدام حقول تنسيق التاريخ

تتحقق قاعدة dateFormat من أن الحقل المقدم هو تاريخ صالح بتنسيق تاريخ محدد.

 $ v -> rule ( ' dateFormat ' , ' created_at ' , ' Y-m-d ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' created_at ' => ' 2018-10-13 ' ]);
$ v -> rules ([
    ' dateFormat ' => [
        [ ' created_at ' , ' Y-m-d ' ]
    ]
]);
$ v -> validate ();

تاريخ قبل استخدام الحقول

تتحقق قاعدة dateBefore من أن الحقل المقدم هو تاريخ صالح قبل تاريخ محدد.

 $ v -> rule ( ' dateBefore ' , ' created_at ' , ' 2018-10-13 ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' created_at ' => ' 2018-09-01 ' ]);
$ v -> rules ([
    ' dateBefore ' => [
        [ ' created_at ' , ' 2018-10-13 ' ]
    ]
]);
$ v -> validate ();

dateAfter استخدام الحقول

تتحقق قاعدة dateAfter من أن الحقل المقدم هو تاريخ صالح بعد تاريخ محدد.

 $ v -> rule ( ' dateAfter ' , ' created_at ' , ' 2018-10-13 ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' created_at ' => ' 2018-09-01 ' ]);
$ v -> rules ([
    ' dateAfter ' => [
        [ ' created_at ' , ' 2018-01-01 ' ]
    ]
]);
$ v -> validate ();

يحتوي على استخدام الحقول

تتحقق قاعدة contains من وجود سلسلة معينة داخل الحقل وتتحقق من أن الحقل وقيمة البحث عبارة عن سلسلتين صالحتين.

 $ v -> rule ( ' contains ' , ' username ' , ' man ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
    ' contains ' => [
        [ ' username ' , ' man ' ]
    ]
]);
$ v -> validate ();

ملاحظة: يمكنك استخدام العلامة الصارمة الاختيارية لضمان وجود تطابق حساس لحالة الأحرف. سيعود المثال التالي صحيحًا:

 $ v = new Valitron  Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
    ' contains ' => [
        [ ' username ' , ' man ' ]
    ]
]);
$ v -> validate ();

حيث أن هذا قد يُرجع خطأ، لأن الحرف M في سلسلة البحث ليس كبيرًا في القيمة المقدمة:

 $ v = new Valitron  Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
    ' contains ' => [
        [ ' username ' , ' Man ' , true ]
    ]
]);
$ v -> validate ();

استخدام حقول المجموعة الفرعية

تتحقق قاعدة subset من أن الحقل إما حقل عددي أو حقل صفيف وأن جميع قيمه موجودة ضمن مجموعة معينة من القيم.

 $ v -> rule ( ' subset ' , ' colors ' , [ ' green ' , ' blue ' , ' orange ' ]);

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' colors ' => [ ' green ' , ' blue ' ]]);
$ v -> rules ([
    ' subset ' => [
        [ ' colors ' , [ ' orange ' , ' green ' , ' blue ' , ' red ' ]]
    ]
]);
$ v -> validate ();

قد يُرجع هذا المثال خطأ، لأن اللون المقدم، الأرجواني، غير موجود في مجموعة القيم المقبولة التي نقدمها.

 $ v = new Valitron  Validator ([ ' colors ' => [ ' purple ' , ' blue ' ]]);
$ v -> rules ([
    ' subset ' => [
        [ ' colors ' , [ ' orange ' , ' green ' , ' blue ' , ' red ' ]]
    ]
]);
$ v -> validate ();

يحتوي على استخدام الحقول الفريدة

تتحقق قاعدة containsUnique من أن الحقل المقدم عبارة عن مصفوفة وأن جميع القيم المضمنة فيه فريدة، أي لا توجد قيم مكررة في المصفوفة.

 $ v -> rule ( ' containsUnique ' , ' colors ' );

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' colors ' => [ ' purple ' , ' blue ' ]]);
$ v -> rules ([
    ' containsUnique ' => [
        [ ' colors ' ]
    ]
]);
$ v -> validate ();

قد يُرجع هذا المثال خطأ، لأن القيم الموجودة في المصفوفة المتوفرة مكررة.

 $ v = new Valitron  Validator ([ ' colors ' => [ ' purple ' , ' purple ' ]]);
$ v -> rules ([
    ' containsUnique ' => [
        [ ' colors ' ]
    ]
]);
$ v -> validate ();

استخدام التحقق من صحة بطاقة الائتمان

يتيح لك التحقق من صحة بطاقة الائتمان حاليًا التحقق من صحة visa Visa أو Mastercard mastercard أو Dinersclub dinersclub أو American Express amex أو Discover discover

سيؤدي هذا إلى التحقق من بطاقة الائتمان مقابل كل نوع بطاقة

 $ v -> rule ( ' creditCard ' , ' credit_card ' );

لتصفية أنواع البطاقات بشكل اختياري، قم بإضافة السلسلة الثابتة إلى مصفوفة كمعلمة تالية:

 $ v -> rule ( ' creditCard ' , ' credit_card ' , [ ' visa ' , ' mastercard ' ]);

إذا كنت تريد التحقق من صحة نوع واحد فقط من البطاقات، فضعها كسلسلة:

 $ v -> rule ( ' creditCard ' , ' credit_card ' , ' visa ' );

إذا كانت معلومات نوع البطاقة تأتي من العميل، فقد ترغب أيضًا في تحديد مصفوفة من أنواع البطاقات الصالحة:

 $ cardType = ' amex ' ;
$ v -> rule ( ' creditCard ' , ' credit_card ' , $ cardType , [ ' visa ' , ' mastercard ' ]);
$ v -> validate (); // false 

مثال على استخدام الحقول

تتحقق قاعدة instanceOf من أن الحقل هو مثيل لفئة معينة.

 $ v -> rule ( ' instanceOf ' , ' date ' , DateTime);

بناء الجملة البديل.

 $ v = new Valitron  Validator ([ ' date ' => new  DateTime ()]);
$ v -> rules ([
    ' instanceOf ' => [
        [ ' date ' , ' DateTime ' ]
    ]
]);
$ v -> validate ();

ملاحظة يمكنك أيضًا مقارنة القيمة بكائن محدد بدلاً من اسم فئة السلسلة. سيعود هذا المثال أيضًا صحيحًا:

 $ v = new Valitron  Validator ([ ' date ' => new  DateTime ()]);
$ existingDateObject = new  DateTime ();
$ v -> rules ([
    ' instanceOf ' => [
        [ ' date ' , $ existingDateObject ]
    ]
]);
$ v -> validate ();

استخدام الحقول الاختيارية

تضمن القاعدة optional أنه في حالة وجود الحقل في مجموعة البيانات فإنه يقوم بتمرير جميع قواعد التحقق من الصحة.

 $ v -> rule ( ' optional ' , ' username ' );

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

 $ v = new Valitron  Validator ([ ' username ' => ' batman ' ]);
$ v -> rules ([
    ' alpha ' => [
        [ ' username ' ]
    ],
    ' optional ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

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

 $ v = new Valitron  Validator ([ ' username ' => ' batman123 ' ]);
$ v -> rules ([
    ' alpha ' => [
        [ ' username ' ]
    ],
    ' optional ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

استخدام حقول arrayHasKeys

تضمن قاعدة arrayHasKeys أن الحقل عبارة عن مصفوفة وأنه يحتوي على كافة المفاتيح المحددة. إرجاع خطأ إذا لم يكن الحقل مصفوفة أو إذا لم يتم تحديد المفاتيح المطلوبة أو إذا كان بعض المفاتيح مفقودة.

 $ v = new Valitron  Validator ([
    ' address ' => [
        ' name ' => ' Jane Doe ' ,
        ' street ' => ' Doe Square ' ,
        ' city ' => ' Doe D.C. '
    ]
]);
$ v -> rule ( ' arrayHasKeys ' , ' address ' , [ ' name ' , ' street ' , ' city ' ]);
$ v -> validate ();

إضافة قواعد التحقق المخصصة

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

 Valitron Validator:: addRule ( ' alwaysFail ' , function ( $ field , $ value , array $ params , array $ fields ) {
    return false ;
}, ' Everything you do is wrong. You fail. ' );

يمكنك أيضًا استخدام القواعد لمرة واحدة والتي تكون صالحة فقط للحقول المحددة.

 $ v = new Valitron  Validator ( array ( " foo " => " bar " ));
$ v -> rule ( function ( $ field , $ value , $ params , $ fields ) {
    return true ;
}, " foo " )-> message ( " {field} failed... " );

يعد هذا مفيدًا لأن مثل هذه القواعد يمكنها الوصول إلى المتغيرات المحددة في النطاق الذي يعيش فيه Validator . توقيع الإغلاق مطابق لتوقيع رد الاتصال Validator::addRule .

إذا كنت ترغب في إضافة قواعدك الخاصة التي ليست ثابتة (على سبيل المثال، قاعدتك ليست ثابتة ومتاحة للاتصال بمثيلات Validator )، فأنت بحاجة إلى استخدام Validator::addInstanceRule . ستأخذ هذه القاعدة نفس المعلمات مثل Validator::addRule ولكن يجب استدعاؤها على نسخة Validator .

قواعد التسلسل

يمكنك ربط عدة قواعد معًا باستخدام بناء الجملة التالي.

 $ v = new Valitron  Validator ([ ' email_address ' => ' [email protected] ' ]);
$ v -> rule ( ' required ' , ' email_address ' )-> rule ( ' email ' , ' email_address ' );
$ v -> validate ();

بناء الجملة البديل لإضافة القواعد

مع تزايد عدد القواعد، قد تفضل الصيغة البديلة لتحديد قواعد متعددة في وقت واحد.

 $ rules = [
    ' required ' => ' foo ' ,
    ' accepted ' => ' bar ' ,
    ' integer ' =>  ' bar '
];

$ v = new Valitron  Validator ( array ( ' foo ' => ' bar ' , ' bar ' => 1 ));
$ v -> rules ( $ rules );
$ v -> validate ();

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

 $ rules = [
    ' required ' => [
        [ ' foo ' ],
        [ ' bar ' ]
    ],
    ' length ' => [
        [ ' foo ' , 3 ]
    ]
];

يمكنك أيضًا تحديد قواعد متعددة لكل نوع قاعدة.

 $ rules = [
    ' length '   => [
        [ ' foo ' , 5 ],
        [ ' bar ' , 5 ]
    ]
];

ومن خلال تجميع هذه التقنيات معًا، يمكنك إنشاء تعريف كامل للقاعدة في بنية بيانات مضغوطة نسبيًا.

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

 $ rules = [
    ' required ' => ' foo ' ,
    ' accepted ' => ' bar ' ,
    ' integer ' =>  ' bar '
];

$ v = new Valitron  Validator ( array ( ' foo ' => ' bar ' , ' bar ' => 1 ));
$ v -> rules ( $ rules );
$ v -> rule ( ' min ' , ' bar ' , 0 );
$ v -> validate ();

يمكنك أيضًا إضافة قواعد على أساس كل حقل:

 $ rules = [
    ' required ' ,
    [ ' lengthMin ' , 4 ]
];

$ v = new Valitron  Validator ( array ( ' foo ' => ' bar ' ));
$ v -> mapFieldRules ( ' foo ' , $ rules );
$ v -> validate ();

أو لحقول متعددة في وقت واحد:

 $ rules = [
    ' foo ' => [ ' required ' , ' integer ' ],
    ' bar ' =>[ ' email ' , [ ' lengthMin ' , 4 ]]
];

$ v = new Valitron Validator(array( ' foo ' => ' bar ' , ' bar ' => '[email protected]));
$v->mapFieldsRules($rules);
$v->validate();

إضافة تسمية الحقل إلى الرسائل

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

لإضافة تسمية فردية إلى القاعدة، ما عليك سوى إضافة طريقة label بعد القاعدة.

 $ v = new Valitron  Validator ( array ());
$ v -> rule ( ' required ' , ' name ' )-> message ( ' {field} is required ' )-> label ( ' Name ' );
$ v -> validate ();

هناك حالة حافة لهذه الطريقة، فلن تتمكن من استخدام مجموعة من أسماء الحقول في تعريف القاعدة، لذلك قاعدة واحدة لكل حقل. لذلك لن ينجح هذا:

 $ v = new Valitron  Validator ( array ());
$ v -> rule ( ' required ' , array ( ' name ' , ' email ' ))-> message ( ' {field} is required ' )-> label ( ' Name ' );
$ v -> validate ();

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

 $ v = new Valitron  Validator ( array ());
$ v -> rule ( ' required ' , array ( ' name ' , ' email ' ))-> message ( ' {field} is required ' );
$ v -> labels ( array (
    ' name ' => ' Name ' ,
    ' email ' => ' Email address '
));
$ v -> validate ();

يقدم هذا مجموعة جديدة من العلامات لملف لغة الخطأ الخاص بك والذي يشبه {field} ، إذا كنت تستخدم قاعدة مثل equals ، فيمكنك الوصول إلى القيمة الثانية في ملف اللغة عن طريق زيادة الحقل بقيمة مثل {field1} .

إعادة استخدام قواعد التحقق من الصحة

يمكنك إعادة استخدام قواعد التحقق الخاصة بك للتحقق بسرعة من صحة البيانات المختلفة بنفس القواعد باستخدام التابع withData:

 $ v = new Valitron  Validator ( array ());
$ v -> rule ( ' required ' , ' name ' )-> message ( ' {field} is required ' );
$ v -> validate (); //false

$ v2 = $ v -> withData ( array ( ' name ' => ' example ' ));
$ v2 -> validate (); //true 

تشغيل الاختبارات

تعتمد مجموعة الاختبار على أداة التحميل التلقائي Composer لتحميل ملفات Valitron وتشغيلها. يرجى التأكد من تنزيل Composer وتثبيته قبل إجراء الاختبارات:

1. قم بتنزيل Composer curl -s http://getcomposer.org/installer | php
2. قم بتشغيل 'تثبيت' php composer.phar install
3. قم بإجراء الاختبارات phpunit

المساهمة

1. شوكة ذلك
2. قم بإنشاء فرع الميزات الخاص بك ( git checkout -b my-new-feature )
3. قم بإجراء التغييرات الخاصة بك
4. قم بإجراء الاختبارات، وأضف اختبارات جديدة للتعليمات البرمجية الخاصة بك إذا لزم الأمر ( phpunit )
5. تنفيذ تغييراتك ( git commit -am 'Added some feature' )
6. ادفع إلى الفرع ( git push origin my-new-feature )
7. إنشاء طلب سحب جديد
8. ربت على ظهرك لكونك رائعًا جدًا

الإفصاحات الأمنية ومعلومات الاتصال

للإبلاغ عن ثغرة أمنية، يرجى استخدام جهة الاتصال الأمنية Tidelift. سوف يقوم Tidelift بتنسيق الإصلاح والكشف.