2012-05-19 12 views
8

जब तक मैं वेब अनुप्रयोग विकसित कर रहा हूं, तब तक मैंने सत्यापन को संभालने के बेहतर तरीकों की तलाश की है। एकाधिक सत्यापन त्रुटियों को पकड़ना अक्सर आवश्यक होता है, इसलिए मैं जानना चाहता था कि निम्नलिखित से इसे करने का बेहतर तरीका है या नहीं।PHP के साथ सत्यापन त्रुटियों को संभालने का सबसे साफ तरीका क्या है?

अभी मेरे पास एक फ्रेमवर्क में assert विधि है जिसे मैंने स्वयं विकसित किया है। विधि का एक उदाहरण यह है:

assert(($foo == 1), 'Foo is not equal to 1');

तो पहला तर्क में हालत गलत है, दूसरा तर्क में त्रुटि संदेश एक $errors सरणी (जो एक कक्षा में लपेटा जाता है में जोड़ा जाता है (द्वारा संदर्भित $eh नीचे) जो सुविधा कार्यों को प्रदान करता है जैसे hasErrors())।

यह विधि काम करती है लेकिन अभ्यास में गन्दा है। इस कोड पर विचार करें:

public function submit($foo, $bar, $baz) 
{ 
    assert(($foo == 1), 'Foo is not equal to 1'); 
    assert(($bar == 2), 'Bar is not equal to 2'); 

    if (!$eh->hasErrors()) 
    { 
     assert(($baz == 3), 'Baz is not equal to 3'); 

     if (!$eh->hasErrors()) 
     { 
      finallyDoSomething(); 
      return; 
     } 
    } 

    outputErrors(); 
} 

यह कुछ आम बात है। मैं आगे बढ़ने से पहले दो स्थितियों की जांच करना चाहता हूं, और फिर यदि वे पास करते हैं, तो आखिरकार ऐसा करने से पहले तीसरी स्थिति की जांच करें जो मैं करना चाहता हूं। जैसा कि आप देख सकते हैं, इस कोड की अधिकांश पंक्तियां सत्यापन से संबंधित हैं। एक वास्तविक आवेदन में, यदि अधिक बयानों और अधिक कथन हो तो अधिक घोंसला होगा।

क्या किसी के पास सत्यापन से निपटने के लिए बेहतर संरचना है? यदि ऐसे ढांचे हैं जो इसे और अधिक सुंदर तरीके से संभालते हैं, तो वे क्या हैं और वे इसे कैसे पूरा करते हैं? कई घोंसले अगर कथन समस्या के ऐसे 'ब्रूट-फोर्स' समाधान की तरह लगते हैं।

बस एक नोट, मैं समझता हूं कि कक्षा में कुछ सामान्य सत्यापन कार्यों को लपेटना शायद एक अच्छा विचार होगा ताकि मैं उन कार्यों को कॉल करके लंबाई, स्ट्रिंग प्रारूप आदि की जांच कर सकूं। मैं जो पूछ रहा हूं वह कोड संरचना के लिए एक क्लीनर दृष्टिकोण है, न कि मैं वास्तव में त्रुटियों की जांच कैसे कर रहा हूं।

धन्यवाद!

उत्तर

6

कृपया Respect\Validation देखें। यह उस purpouse के लिए बनाया गया एक पुस्तकालय है। यह कई नियमों को बहुत आसानी से संभाल सकता है और त्रुटियों के लिए अपवादों का उपयोग करता है।

<?php 

use Respect\Validation\Validator as v; 

$usernameValidator = v::alnum()->noWhitespace()->length(1,15); 

$valid = $usernameValidator->validate("alganet"); //$valid now == true 
$valid = $usernameValidator->validate("ácido acético"); //$valid now == false 

अब अपवाद का उपयोग कर:: यहाँ एक त्वरित नमूना है

array(
    "alnum" => '"foo # bar" must contain only letters and digits', 
    "noWhitespace" => '"foo # bar" must not contain whitespace', 
    "length" => null 
) 

मैं दो तोड़ दिया कि पहले की घोषणा की:

try { 
    $usernameValidator->assert("foo # bar"); 
} catch (Exception $e) { 
    $errors = $e->findMessages('alnum', 'noWhitespace', 'length'); 
} 

ऊपर नमूने में, $errors चर कुछ इस तरह होगा "foo # bar" का उपयोग कर नियम: इसमें व्हाइटस्पेस है और इसमें एक गैर-एलनम चार है। प्रत्येक नियम के लिए जो पास नहीं होता है, एक संदेश वापस कर दिया जाएगा। चूंकि "लंबाई" ठीक है, त्रुटि संदेश शून्य है।

documentation में नेस्टेड, पदानुक्रमित नियमों और बेहतर अपवाद हैंडलिंग सहित कई और नमूने शामिल हैं। सत्यापनकर्ताओं में निर्मित सभी 30+ के लिए नमूने की विस्तृत सूची भी है।

आशा है कि मदद करता है!

+0

मुझे इस पुस्तकालय को बहुत पसंद है, मुझे लगता है कि मैं यह देखता हूं कि यह अधिक विस्तार से कैसे काम करता है और अपनी सुविधाओं को अपने स्वयं के ढांचे में दोहराने का प्रयास करता है। धन्यवाद! –

+0

* प्रमाणीकरण * शानदार है, मैंने देखा सबसे अच्छा है। आप के लिए यश! –

+2

+1। आखिरकार मैंने एक त्वरित परियोजना पर 'सम्मान \ सत्यापन' की कोशिश की। बहुत उपयोगी पुस्तकालय! –

4

अपवाद फेंकने के बारे में कैसे? आप प्रयास/पकड़ ब्लॉक के साथ अपवादों की व्याख्या कर सकते हैं, और/या उन्हें set_exception_handler()

PHP में परिभाषित कई उपयोगी अपवाद प्रकार हैं, जिन्हें आप अपने लाभ के लिए उपयोग कर सकते हैं यदि आपको निष्पादन हैंडलिंग में ग्रैन्युलरिटी की आवश्यकता है। इसके अलावा आप कस्टम अपवादों को परिभाषित कर सकते हैं।

http://php.net/manual/en/function.set-exception-handler.php http://www.php.net/manual/en/spl.exceptions.php

संपादित

के बारे में कैसे कुछ अन्य व्यवस्थाएं इस समस्या दृष्टिकोण आपके प्रश्न का उत्तर करने के लिए - विवेकपूर्ण अपवादों का उपयोग बहुत आम लगता है। उनका उपयोग करने के बारे में उपयोगी बात यह है कि, आपके पास एक विशेष विधि है जो कई अलग-अलग मान्यताओं को संभवतः गलत कर सकती है - आप प्रत्येक मामले में एक अप्रिय अपवाद फेंक सकते हैं, लेकिन आपको विभिन्न संभावित अपवादों को संभालने की आवश्यकता नहीं है वह विधि इसके बजाए, आप अपने कोड को कैसे व्यवस्थित करते हैं, इस पर निर्भर करते हुए, आप अपवाद को अपने कोड में एक और केंद्रीकृत स्थान पर बुलबुला करने की अनुमति दे सकते हैं जहां आप इसे पकड़ सकते हैं और इसे उचित तरीके से संभाल सकते हैं।

संपादित 2

मेरा आखिरी टिप्पणी पर विस्तार करने के लिए के बारे में filter_input_array()

पोस्टेड उपयोगकर्ता डेटा के साथ एक बहुत ही सरल उदाहरण के आधार पर।

$userFormDefinition = array(
    'email' => FILTER_VALIDATE_EMAIL, 
    'age' => FILTER_VALIDATE_INT, 
    'name' => array(
     'filter' => FILTER_VALIDATE_REGEXP, 
     'options' => array('regexp' => '/^\w+$/') 
    ), 
); 

तो एक सामान्य सत्यापन वर्ग (नीचे वर्ग परिभाषा) का उपयोग: एक FormValidator की

$formValidator = new FormValidator(); 
$formValidator->validatePost($userFormDefinition); 

if ($formValidator->isValid()) { 

    // if valid, retrieve the array 
    // and use the values how you wish 

    $values = $formValidator->getValues(); 

    // for example, extract and populate 
    // a User object, or whatever :) 

    extract($values); 

    $user = new User(); 
    $user->setName($name); 
    $user->setEmail($email); 
    $user->setAge($age); 

    // etc. 
} 

एक बहुत ही बुनियादी (और untested) कार्यान्वयन सबसे पहले एक परिभाषा पैदा करते हैं।

मूल उपयोग केस अनुरोध विधि के खिलाफ फ़िल्टर करने के लिए उचित विधि को कॉल करना है। यह बदले में लौटे गए मूल्यों की जांच करता है और यह तय करता है कि इनपुट मान्य है या नहीं। , विशेष रूप सेfilterInput विधि क्योंकि आप कुछ परीक्षण करने के लिए हो सकता है आप उचित रूप से निपटने 'truthy' या 'falsy' मूल्यों सुनिश्चित करने के लिए -

यह प्यार का एक बहुत इस्तेमाल कर सकते हैं। मैं चेकबॉक्स प्रकार मान सोच रहा हूँ। सीधे in_arrayfalse के लिए जांच करें इसे यहां लागू नहीं किया जा सकता है। लेकिन वहां झंडे के भार हैं जिन्हें आप परिभाषा के साथ पारित कर सकते हैं।

मुझे लगता है कि परिणामस्वरूप $values सरणी और परिभाषा की गिनती करके आप लापता इनपुट की जांच भी कर सकते हैं, यह सुनिश्चित करने के लिए कि वे मेल खाते हैं। परिभाषा में नहीं अतिरिक्त इनपुट फ़िल्टर किए गए हैं (आप इसे जांचना चाहेंगे लेकिन मैं अपने सिर के शीर्ष से इस बारे में निश्चित रूप से निश्चित हूं)।

<?php 

class FormValidator 
{ 
    private $isValid = false; 

    private $isBound = false; 

    private $values = array(); 

    public function validatePost(array $definition) 
    { 
     // additional REQUEST_METHOD checking here? 
     $this->filter(INPUT_POST, $definition); 
    } 

    public function validateGet(array $definition) 
    { 
     // additional REQUEST_METHOD checking here? 
     $this->filterInput(INPUT_GET, $definition); 
    } 

    protected function filterInput($type, $definition) 
    { 
     $this->isBound = true; 

     $this->values = filter_input_array($type, $definition); 

     // might have to do some reading on nulls vs false, 
     // and validating checkbox type values here... you can 
     // set all sorts of flags so a better implementation 
     // would probably be required here... :s 

     if (is_array($this->values) && !in_array(false, $this->values))) { 
      $this->isValid = true; 
     } 
    } 

    public function isValid() 
    { 
     if (!$this->isBound) { 
      throw new Exception("you didn't validate yet!"); 
     } 

     return $this->isValid; 
    } 

    public function getValues() 
    { 
     if (!$this->isBound) { 
      throw new Exception("You didn't validate yet!"); 
     } 

     return $this->values; 
    } 
} 

वैसे भी, मैं refactor कहेंगे, उस क्लास के बाहर bejayzis परीक्षण, (या यहां तक ​​कि पूरी तरह से इसे बदल), लेकिन उम्मीद है कि यह मूल विचार की रूपरेखा: इनपुट के प्रत्येक प्रकार के लिए, एक परिभाषा बनाने और उसके बाद का उपयोग एक फ़िल्टर करने और वैधता सुनिश्चित करने के लिए जेनेरिक सत्यापन वर्ग।

उम्मीद है कि इससे मदद मिलती है। filter_input और filter_input_array रॉक :)

+1

मैंने उसमें देखा है लेकिन जब मैंने पूछा तो वास्तव में एक बड़ी प्रतिक्रिया नहीं मिली। मैंने जो प्रतिक्रियाएं प्राप्त की थी वे अपवादों के पक्ष में नहीं थीं। http://stackoverflow.com/questions/10196227/how-to-make-good-use-of-php-error-handling-throwing-exceptions –

+0

दिलचस्प: यहाँ मेरे सवाल देखें। मुझे लगता है कि राय अलग-अलग होती है - वे निश्चित रूप से उपयोग करते हैं। उनके साथ ओवरबोर्ड (कुछ भी पसंद है) जाना संभव है, लेकिन मुझे लगता है कि अपवादों का उचित उपयोग निश्चित रूप से उपयोगी है। IMHO। ऐसा लगता है कि मुझे सांस्कृतिक चीज की तरह लगता है - अन्य भाषाएं उनके उपयोग को और अधिक गले लगती हैं। –

+0

हां। कुछ और पढ़नाइस विषय पर राय जंगली दिखती है। कुछ असाधारण * परिस्थितियों के लिए एक हाथ से अपवादों को बताया जाता है - जब स्थिति आपके नियंत्रण से बाहर होती है। एक अच्छा उदाहरण है कि दिमाग में स्प्रिंग्स पीडीओ ऑब्जेक्ट बना रहा है - आप इसे डीबी से कनेक्ट करते समय संभावित त्रुटियों के असंख्य को संभालने के लिए कोशिश/ब्लॉक में लपेट सकते हैं। उस ने कहा, यदि आप सिम्फनी 2 के वैलिडेटर घटक को देखते हैं, तो इसके कई वर्ग एक तर्क के उद्भव के आधार पर अप्रत्याशित ValueExceptionException फेंक देते हैं। मैं अपना हाथ ऊपर रखूंगा और कहूंगा कि यह स्वाद का विषय है। और संभवतः व्यवहार :) –

0

नीचे मैं एक उदाहरण आप कैसे (अपनी स्थिति के लिए गैर विशिष्ट) सामान्य रूप में अपवाद का उपयोग करें और कुछ है कि आप के लिए और अधिक विशिष्ट है (अब भी अपवाद का प्रयोग करके) नीचे आगे बढ़ाने के लिए पता चलता है कि लिखा है। ये पहले दो उदाहरण एक समय में 1 त्रुटि को संभालेगा। मैंने प्रदान किया तीसरा उदाहरण कई त्रुटियों और अपवादों को संभालने का एक उदाहरण देता है।

स्पष्टीकरण के अधिकांश कोड की टिप्पणी में है, इसलिए अच्छी तरह से यह माध्यम से देखने के लिए :)

जनरल अपवाद संचालन सुनिश्चित हो

<?php 
//Define some variables to work with 
$var = false; 
$var2 = false; 

try { //Outer try 
    echo 'Do something here!<br />'; 

    try { //Inner try 
     if($var !== true) { //Fail 
      throw new Exception('$var is not true',123); //Exception is thrown (caught 2 lines down) 
     } 
    } catch (Exception $e) { //Exception caught here 
     echo 'InnerError# '.$e->getCode().': '.$e->getMessage().'<br />'; //Exception handled (in this case printed to screen) 
    } 

    //Code is continuing here even after the exception was thrown 
    echo 'Do something else here!<br />'; 

    if($var2 !== true) { //Fail 
     throw new Exception('$var2 is not true', 456); //Exception is thrown (caught 6 lines down) 
    } 

    //Code fails to run as the exception above has been thrown and jumps straight into the below catch 
    echo 'Do the third thing here!<br />'; 

} catch (Exception $e) { //Exception caught here 
    echo 'Error # '.$e->getCode().': '.$e->getMessage().' on line '.$e->getLine().' in '.$e->getFile().'<br />'; //Exception handled (in this case printed to screen) 
} 

//Code is continuting here even after both of the exceptions 
echo 'Do even more stuff here!<br />'; 
?> 

स्टैंडर्ड अपवाद वर्ग निर्माता:

public __construct ([ string $message = "" [, int $code = 0 [, Exception $previous = NULL ]]]) 

कस्टम अपवाद

अब, अपने उदाहरण से संबंधित करते, आप कुछ इन पंक्तियों के साथ कर सकता है:

<?php 
class customException extends Exception { //Create a custom exception handler that allows you to pass more arguments in the constructor    
    public function __construct($errorString, $errorNumber, $errorFile, $errorLine) { 
     $this->message = $errorString; //Using the Exception class to store our information 
     $this->code = $errorNumber; 
     $this->file = $errorFile; 
     $this->line = $errorLine; 
    } 
} 

function err2Exception($errNo, $errStr, $errFile, $errLine) { //This function converts the error into an exception 
    throw new customException($errStr, $errNo, $errFile, $errLine); //Throw the customException 
} 

set_error_handler('err2Exception'); //Set the error handler to the above function 

try { 
    assert(1==2); //This fails, calls the function err2Exception with the correct arguments, throws the error and is caught below 
} catch (Exception $e) { //Error caught as an Exception here 
    //Echo out the details (or log them, or whatever you want to do with them) 
    echo 'Error String: '.$e->getMessage().'<br />'; 
    echo 'Error Number: '.$e->getCode().'<br />'; 
    echo 'File containing error: '.$e->getFile().'<br />'; 
    echo 'Line with error: '.$e->getLine().'<br />'; 

} 
?> 

http://php.net/manual/en/function.set-error-handler.php

उपरोक्त कोड का आउटपुट:

Error String: assert(): Assertion failed

Error Number: 2

File containing error: 18

Line with error: /var/www/test2.php

आप कस्टम त्रुटि हैंडलिंग के इस दूसरे उदाहरण के साथ पहली बार कोड उदाहरण में घोंसले try/catch बयानों की अवधारणाओं को लागू कर सकते हैं।

हैंडलिंग अनेक त्रुटियां/अपवाद

<?php 
class errorLogger { //create an errorLogger class 
    private $errors; //Stores all errors 

    public function addError($errCode, $errMsg, $errFile = null, $errLine = null) { //Manually add an error 
     $this->errors[] = array(//Add to the error list 
      'code' => $errCode, 
      'message' => $errMsg, 
      'file' => $errFile, 
      'line' => $errLine 
     ); 
    } 

    public function addException($exception) { //Add an exception to the error list 
     $this->errors[] = array(//Add to the error list 
      'code' => $exception->getCode(), 
      'message' => $exception->getMessage(), 
      'file' => $exception->getFile(), 
      'line' => $exception->getLine() 
     ); 
    } 

    public function getErrors() { //Return all of the errors 
     return $this->errors; 
    } 

    public function numErrors() { //Return the number of errors 
     return count($this->errors); 
    } 
} 

$el = new errorLogger(); //New errorLogger 
set_error_handler(array($el, 'addError')); //Set the default error handler as our errorLoggers addError method 
set_exception_handler(array($el, 'addException')); //Set the default exception handler as our errorLoggers addException method 

if(!is_numeric('a')) //Will fail 
    $el->addError('Invalid number', 1); //Adds a new error 

if(($name = 'Dave') !== 'Fred') //Will fail 
    $el->addError('Invalid name ('.$name.')', 2, 'test.php', 40); //Adds another error 

assert(1==2); //Something random that fails (non fatal) also adds to the errorLogger 

try { 
    if('Cats' !== 'Dogs') //Will fail 
     throw new Exception('Cats are not Dogs', 14); //Throws an exception 
} catch (Exception $ex) { //Exception caught 
    $el->addException($ex); //Adds exception to the errorLogger 
} 

trigger_error('Big bad wolf blew the house down!'); //Manually trigger an error 

//throw new Exception('Random exception', 123); //Throw an exception that isn't caught by any try/catch statement 
               //(this is also added to the errorLogger, but any code under this is not run if it is uncommented as it isn't in a try/catch block) 

//Prints out some 
echo '<pre>'.PHP_EOL; 
echo 'There are '.$el->numErrors().' errors:'.PHP_EOL; //Get the number of errors 

print_r($el->getErrors()); 

echo '</pre>'.PHP_EOL; 
?> 

जाहिर है आप बदल सकते हैं और विशेष रूप से आपकी आवश्यकताओं के अनुरूप errorLogger वर्ग अनुकूलित कर सकते हैं।

उपरोक्त कोड का आउटपुट:

There are 5 errors:

Array (

[0] => Array 
    (
     [code] => Invalid number 
     [message] => 1 
     [file] => 
     [line] => 
    ) 

[1] => Array 
    (
     [code] => Invalid name (Dave) 
     [message] => 2 
     [file] => test.php 
     [line] => 10 
    ) 

[2] => Array 
    (
     [code] => 2 
     [message] => assert(): Assertion failed 
     [file] => /var/www/test.php 
     [line] => 42 
    ) 

[3] => Array 
    (
     [code] => 14 
     [message] => Cats are not Dogs 
     [file] => /var/www/test.php 
     [line] => 46 
    ) 

[4] => Array 
    (
     [code] => 1024 
     [message] => Big bad wolf blew the house down! 
     [file] => /var/www/test.php 
     [line] => 51 
    ) 

)

ऊपर कोड आप कर सकते हैं:

  • फेंक अपवाद और उन्हें errorLogger
  • में जोड़ने के लिए यादृच्छिक कार्यों से किसी भी बिना क्रिया स्थितियों को संभाल कि आमतौर पर करते हैं त्रुटियों को प्रदर्शित करने के कारण
  • अपनी खुद की त्रुटियां मैन्युअल रूप से जोड़ें
  • उत्प्रेरक त्रुटियों (http://uk3.php.net/trigger_error)

तो आपको प्रदर्शन/प्रवेश कर सकते हैं/जो कुछ भी बाद में किसी समय त्रुटियों के सभी।

एनबी: उपरोक्त कोड के सभी नकल की और सीधे चिपकाए आप

+0

अपवादों को कोड के निष्पादन को रोकना नहीं है? अगर मैं कई सत्यापन नहीं करना चाहता हूं और सभी त्रुटियों को वापस कराना चाहता हूं, तो पहली त्रुटि पर अपवाद फेंकने से बाकी संभावित त्रुटियों को नहीं पकड़ा जाएगा। क्या ये सही है? –

+0

* खांसी * हाँ, लॉल। मैंने आपकी पोस्ट में 'एकाधिक' बिट को अनदेखा कर दिया। मैंने अभी भी कुछ जवाब मेरे जवाब में जोड़ा है। – vimist

2

के साथ प्रयोग करने के लिए कुछ देने के लिए किया जा सकता है जब आप कहते हैं कि "मान्यता" - मैं यह सोचते हैं कि आप उपयोगकर्ता इनपुट को मान्य कर रहे हैं इससे पहले कि आप एक कर कार्रवाई।मैं अक्सर jQuery द्वारा AJAX के साथ डेटा सबमिट करते समय या जब मैं किसी वेब-सेवा से प्रतिक्रिया दे रहा हूं तो इसका उपयोग करता हूं।

यदि ऐसा है, तो आप मेरे very simple validation class पर देख सकते हैं।

<?php 

$validator = new Validator(); 

// Each validation rule is a property of the validator object. 
$validator->username = function($value, $key, $self) 
{ 
    if(preg_match('~\W~', $value)) 
    { 
     return 'Your username must only contain letters and numbers'; 
    } 
}; 

$validator->password = function($value, $key, $self) 
{ 
    if(strlen($value) < 8) 
    { 
     return 'Your password must be at least 8 characters long'; 
    } 
}; 

if(! $validator($_POST)) 
{ 
    die(json_encode($validator->errors())); 
} 

// ... register user now 

आप इसे किसी भी डेटा को सत्यापित करने के लिए उपयोग कर सकते हैं - जब तक यह सरणी रूप में है। केवल $ _POST/$ _ एआरई प्राप्त नहीं करें।

1

हमने विभिन्न ढांचे की संख्या बनाई और उपयोग की है। फॉर्म हैंडलिंग आमतौर पर वेब अनुप्रयोगों के निर्माण का एक अनिवार्य हिस्सा है। इसलिए, त्रुटि प्रबंधन के बारे में आपके प्रश्न का उत्तर देने के लिए, मैं इस सवाल को अधिक व्यापक रूप से देखने का सुझाव दूंगा।

स्पष्ट रूप से, किसी भी चीज़ को सत्यापित करने के लिए, आपको इनपुट डेटा की कुछ प्रकार और परिभाषा इनपुट डेटा की आवश्यकता है। इसके बाद, क्या आपके पास एक फॉर्म है या आप एक से अधिक रूपों के लिए केंद्रीकृत सत्यापन करने की योजना बना रहे हैं। यदि, तो, सामान्य वैधता ऑब्जेक्ट बनाना समझ में आता है।

class validator {} 

ठीक है, तो, सत्यापनकर्ता अच्छी तरह से काम करने के लिए, यह पता होना चाहिए कि क्या मान्य है और कैसे करने के लिए। तो, यहां हम सवाल बनाते हैं कि आप फ़ॉर्म कैसे बनाते हैं - वे गतिशील हैं, मॉडल के आधार पर, या वे सादे HTML हैं। यदि मॉडल मॉडल पर आधारित है, तो आमतौर पर इसमें सभी फ़ील्ड परिभाषित होते हैं और आमतौर पर अधिकांश सत्यापन नियम मॉडल स्तर पर मौजूद होते हैं। उस स्थिति में, मॉडल से फ़ील्ड सीखने के लिए अपने सत्यापनकर्ता को सिखाना समझ में आता है।

$fields = array(
    "name" => array("notNull"), 
    "age" => array("notNull", array("size", 13, 99)) 
); 
दृष्टिकोण से ऊपर

आप प्रमाणकों परिभाषित करने देता है (एक या अधिक:

function setModel($model){} 
function getFields(){ -- iterates through $model fields} 

वैकल्पिक रूप से, अगर आप मॉडल का उपयोग नहीं करते और फार्म सादा एचटीएमएल, खेतों और सत्यापनकर्ता के सरल सरणी है सबसे समझ में आता है), और प्रत्येक सत्यापनकर्ता में अतिरिक्त पैरा हो सकते हैं। इस मामले में, अपने सत्यापनकर्ता लगेगा जैसे:

function validate($data, $fields){ 
    $this->valid = true; 
    $this->data = $data; 
    foreach ($fields as $field_name => $validators){ 
     foreach ($validators as $v){ 
      $params = array($field_name, isset($data[$field_name])?$data[$field_name]:null); 
      if (is_array($v)){ 
       $m = "_" . $v[0]; 
       unset($v[0]); 
       $params = array_merge($params, $v); 
      } else { 
       $m = "_" . $v; 
      } 
      if (method_exists($this, $m)){ 
       call_user_func_array(array($this, $m), $params); 
      } 
     } 
    } 
    if (!empty($this->errors)){ 
     $this->valid = false; 
    } 
    return $this->valid; 
} 

अच्छी बात यह है कि आप निम्नलिखित तरीके से सत्यापनकर्ता वर्ग के लिए नई विधियों के रूप में अपने अगले प्रमाणकों के साथ जोड़ सकते हैं:

function _notNull($field_name, $value){ 
    if (!$value){ 
     $this->errors[$field_name][] = "Must be filled"; 
    } 
} 

function _size($field_name, $value, $min = null, $max = null){ 
    if ($value < $min && $min){ 
     $this->errors[$field_name][] = "Must be at least $min"; 
    } else if ($value > $max && $max){ 
     $this->errors[$field_name][] = "Must be at most $max"; 
    } 
} 
तो

, फिर, का उपयोग करते हुए इस दृष्टिकोण में आपके पास वैधता वर्ग होगा जिसे आसानी से बढ़ाया जा सकता है, आपके पास वैधकर्ताओं के लिए कई पैरामीटर हो सकते हैं, और वैधकर्ता रेगेक्स/फ़िल्टर या फ़ील्ड को सत्यापित करने की किसी भी अन्य विधि का उपयोग कर सकते हैं। अंत में, $this->errors array में फ़ील्ड और त्रुटियों के साथ सहयोगी सरणी होगी। इसके अलावा, प्रति फ़ील्ड केवल एक त्रुटि, उपयोगकर्ता को भ्रमित नहीं करने के लिए। और स्पष्ट रूप से आप पर्यावरण के आधार पर केवल सरणी या मॉडल का उपयोग कर सकते हैं जिसमें सत्यापन होगा।

0

आपको आराम करने में मदद करने के लिए, आप जो भी करते हैं, इससे कोई फर्क नहीं पड़ता, आप उसी मूल प्रक्रियात्मक लूप के साथ समाप्त होने जा रहे हैं जैसा आप वर्णन करते हैं। आप घोंसले को थोड़ा हटा सकते हैं (नीचे देखें) लेकिन ज्यादा नहीं।

सत्यापन के लिए, आपको एक प्रक्रियात्मक प्रवाह की आवश्यकता है, जो आपके पास है। सूक्ष्म भिन्नताएं हो सकती हैं (जैसे कि आप कुछ अन्य फ़ील्ड गलत होने पर भी संयोजक सत्यापनकर्ता कर सकते हैं) लेकिन यह प्रक्रियात्मक प्रवाह है। "मैदान" वर्गों, और पाश उन के माध्यम से, या सत्यापन की स्थिति और पाश उन यद्यपि की एक सरणी जोड़ने -

1. Loop through all fields, and validate them; store errors if any 
2. If (no errors) { 
3.  loop though all multiple combinations and validate them, store errors if any 
4. } 
5. If (no errors) { 
6.  do action, store errors if any 
7. } 
8. If (no errors) { 
9.  Report back success 
10. } else { 
11. Report back problems 
12. } 

एक कोडिंग परिप्रेक्ष्य आप लगभग किसी भी जवाब में से वहाँ का पालन कर सकते से इसे और अधिक कुशल बनाने के लिए। आप "वैधकर्ता वर्ग" जोड़ सकते हैं (लेकिन आपको दो प्रकार की आवश्यकता होगी - फ़ील्ड से जुड़ा एक प्रकार, फ़ॉर्म से जुड़ा एक प्रकार) और आप उपरोक्त लूप पर वापस फेंकने के लिए अपवादों का उपयोग कर सकते हैं - लेकिन वह आधार प्रक्रियात्मक लूप आपको चिंतित नहीं होगा कभी नहीं बदलेगा।

  1. "फील्ड सत्यापनकर्ता" वर्ग है कि क्षेत्र की लंबाई के प्रकार पुष्टि अनिवार्य आदि
  2. :


    लेकिन अधिक उचित तरह से मैं (बड़ी परियोजनाओं पर) काम जवाब देने के लिए एक है

  3. "फॉर्म वैलिडेटर" वर्ग जो डेटा इत्यादि के विशिष्ट संयोजनों को मान्य करता है
  4. "फ़ॉर्म" वर्ग जो फ़ॉर्म के कार्यों को नियंत्रित करता है। यह भी उपयोगी है कि विभिन्न प्रकार के फॉर्म क्लास डेटाबेस से लिंक कर सकते हैं (वीबी/सी # नेट के समान) और फ़ील्ड प्रकारों से फ़ील्ड सत्यापन में खींचें और मानक "एडिट", "एड" और "डिलीट" कार्यक्षमता है।
  5. "फ़ील्ड" कक्षा जो फ़ील्ड के कार्यों को नियंत्रित करती है। फील्ड भी एक डीबी से जोड़ा जा सकता, अन्य क्षेत्रों के आदि से जुड़ा हुआ

फार्म ठीक उसी प्रक्रियात्मक संरचना के साथ मान्य होगा, सिवाय इसके कि यह क्षेत्र वस्तुओं (नहीं कच्चे क्षेत्रों) के माध्यम से लूप होता है, और अपवादों को वापस थूक वह लूप जो फ़ॉर्म के खिलाफ त्रुटियों को संग्रहीत करता है (जैसा कि दारग द्वारा सुझाया गया है)। कक्षाओं के साथ यह

ढांचे के ओवरहैंग के बिना त्वरित परियोजनाओं (एक पृष्ठ रूपों) के लिए, मैं केवल विशिष्ट सत्यापन के साथ अपने कोड का उपयोग करता हूं। (यह व्यक्तिगत पसंद है - दूसरों कहेंगे आप हमेशा यहां तक ​​कि छोटे परियोजनाओं के लिए ढांचे का उपयोग करना चाहिए, दोनों विकल्प मान्य होते हैं और एक चर्चा के लिए यहां कभी-कभी मैं सिर्फ एक मध्य स्तर विकल्प का उपयोग होता नहीं जो भी सूट परियोजना।।।)

लेकिन इससे कोई फर्क नहीं पड़ता कि बेस प्रक्रियात्मक लूप समान है। इसके बारे में आप कुछ भी नहीं करते हैं जैसा कि आवश्यक है।

संबंधित मुद्दे

 संबंधित मुद्दे