Ben başka bir sınıf geliştirmek gerektiğini düşünüyorum: Bir ValidatorChain, onaylayıcıların keyfi bir miktar alır, ve o test etmiş tüm onaylayıcıların errormessages agrega

Başvuru için docs on Zend Framework's Validator Chain bakın

EDIT

Ben sorunuzu yeniden değerlendirmek Şimdi (Bryan M yorumuna teşekkürler); neden her Validator diğer Doğrulayıcıları'nın 'hata iletileri erişmesini istiyorsun? Ben her Doğrulayıcıları'nın 'hata mesajları toplama hiyerarşisinde daha yüksek bir nesnenin sorumluluğu olduğunu söyleyebilirim.

Ancak, bireysel Doğrulayıcıları bağlamına göre hareket edebilmek istiyorsanız, diğer Doğrulayıcıları'nın sonuçları ne dayalı diğer bir deyişle,, o zaman isCorrect için $ context parametresini ekleyebilirsiniz varsayalım yöntemi. Bu, örneğin bir Doğrulayıcıları'nın keyfi miktarda veya benzer bir şey kabul edemedi.

Gibi bir şey:

interface ValidatorInterface
{
    public function isCorrect( array $context );
    public function getMessages();
}

abstract class ValidatorContextOptions
{
    const SHOULD_BE_PRESENT = 'shouldBePresent';
    const SHOULD_NOT_BE_PRESENT = 'shouldNotBePresent';
    const SHOULD_BE_VALID = 'shouldBeValid';
}

class EmailValidator implements ValidatorInterface
{
    protected $_field;

    protected $_contextOptions = array();

    protected $_messages = array();

    public function __construct( $field, array $contextOptions )
    {
        $this->_field = $field;
        $this->_contextOptions = $contextOptions;
    }

    public function isCorrect( array $context = null )
    {
        foreach( $this->_contextOptions as $field => $options )
        {
            foreach( $options as $option )
            {
               switch( $option )
               {
                   case ValidatorContextOptions::SHOULD_NOT_BE_PRESENT:
                       if( isset( $context[ $field ] )
                           && $context[ $field ] instanceof ValidatorInterface )
                       {
                           $this->_messages[] = $field . ' should not be present';
                           return false;
                       }
                       break;
                   case ValidatorContextOptions::SHOULD_BE_PRESENT:
                       if( !isset( $context[ $field ] )
                           || !$context[ $field ] instanceof ValidatorInterface )
                       {
                           $this->_messages[] = $field . ' should be present';
                           return false;
                       }
                       break;
                   case ValidatorContextOptions::SHOULD_BE_VALID:
                       if( !isset( $context[ $field ] )
                           || !$context[ $field ] instanceof ValidatorInterface
                           || !$context[ $field ]->isCorrect() )
                       {
                           $this->_messages[] = $field . ' should be valid';
                           return false;
                       }
                       break;
               }
            }
        }

        // some dummy function which you should replace with real validation
        return isAnEmailAddress( $this->_field );
    }

    public function getMessages()
    {
        return $this->_messages;
    }
}

Kullanımı:

$emailValidatorContextOptions = array
(
    'phone' => array( 
                   ValidatorContextOptions::SHOULD_BE_PRESENT,
                   ValidatorContextOptions::SHOULD_BE_VALID
               )
);

$phoneValidator = new PhoneValidator( $phoneString );
$emailValidator = new EmailValidator( $emailString, $emailValidatorContextOptions );

if( !$emailValidator->isCorrect( array( 'phone' => $phoneValidator ) ) )
{
    print_r( $emailValidator->getMessages() );
}

Ben çizdiğim, çok daha fazla düşünme (ve ben gerçekten çok demek) ihtiyacı vardır, cehennem ve kesinlikle kurşun geçirmez olarak değil adamcağız. Ama ben bu ile gidiyorum nerede anladınız umarım.

Ayrıca, yine valide edilmesi gereken sizin doğrulayıcısındaki değerleri nereye ekleyebilirim?

Peki size ben genelde almak yaklaşımdır dosyaları özellikleri bahsediyoruz varsayarak, mülkiyet erişimi kontrol etmek için harici özellikler fabrika yapabiliriz.

Eğer paylaşılan bir alana başvuruyorsunuz, o zaman baz sınıfta yer ve bu şekilde erişebilirsiniz.

Ben sık sık Zend_Validate sınıfları doğrulama gerçekleştirmek için kullanmak, ve onaylanmış ediliyor nesne üzerinde bir özelliği herhangi bir hata mesajı agrega (yanı sıra geçerli durumunu kontrol bayrak) olacak.

Benim kurulum buna benzer olacaktır:

class User {
  public $email;
  protected $_errorMessages = array();

  public function validate()
  {
    $valid = true;

    $emailValidator = new EmailValidator();
    if (!$emailValidator->isCorrect($this->email)) {
      $valid = false;

      // validation message are added to the $errormessages property in
      // the validator class upon failure of isCorrect()
      $this->_errorMessages[] = $emailValidator->getMessages();
    }

    // repeat this for all your validators

    return $valid
  }

  public function getErrorMessages()
  {
     return $this->_errorMessages();
  }
}

// in your page....
if (!$user->validate()) {
  $messages = $user->getErrorMessages();
}

Seni doğru okursanız, birden çok örneğini birkaç doğrulayıcılar örneğini ve hepsini tek bir dizi katkıda olabilir, öyle ki aynı hata iletileri özelliği paylaşmak istiyorum.

Bu durumda ise, bunu yapmak için birkaç yolu vardır. Bir doğrulayıcılar başlatmasını ve kayıt için sorumluluğu olan bir validator yönetici sınıfı oluşturmak olacaktır. Doğrulama işlemi tamamlandıktan sonra o zaman kayıtlı tüm doğrulayıcılarıyla mevcut hataları toplamak hangi $validator_manager->getErrors() diyebiliriz.

Bunu yapabileceği başka bir yolu her validator yapıcısı olarak elde bir tek hata mağaza sınıf kullanmak olacaktır. Her denetleyicidir addError() yöntemi sonra tekiz işi havale ederdi.

Orada diğer yöntemler hala vardır, ama temelde doğrulayıcılar yönetmek veya hataları saklamak için ya da başka bir nesne kullanmak zorunda gidiyoruz.

Birisi aşağıda Bunun için singleton'ununu kullanarak söz.

Ben genellikle tekil "anti-model" olduğunu savundular ve genellikle aşırı / yanlış kullanılan özellikle bu yana, bu tasarım deseni büyük bir kullanım olduğunu ikna değilim.

Bununla birlikte, akılda tutarak, burada bu doğrultuda bir örnek:

<?php

//Error Class implemented as a Singleton
class ErrorClass
{

  static private $instance = false;
  static private $errorMessages;

  function getInstance() {
    if (!self::$instance) {
      self::$instance = new ErrorClass();
      self::$errorMessages = "No errors;";
    }
    return self::$instance;
  }

  public function setError($errorMessage){
    self::$instance->errorMessages .= $errorMessage;
  }

  public function getError(){
    return self::$instance->errorMessages;
  }

}

abstract class AbstractClass
{

  // Force Extending class to define this method
  abstract protected function isCorrect($b);

  // Common Method for setting error
  public function setError($errorMessage) {
    ErrorClass::getInstance()->setError($errorMessage);   
  }

  // Common Method for getting error
  public function getError() {
    return ErrorClass::getInstance()->getError();   
  }
}

class EmailValidator extends AbstractClass
{

  public function isCorrect($b) {
    if(!$b) {
      $this->setError('EmailValidator->isCorrect();');
    }
  }

}

class PasswordValidator extends AbstractClass
{

  public function isCorrect($b) {
    if(!$b) {
      $this->setError('PasswordValidator->isCorrect();');
    }
  }

}

// Then in your code
$errorState = 1; // used for testing purposes

$EmailValidator = new EmailValidator(); 
$EmailValidator->isCorrect($errorState);

$PasswordValidator = new PasswordValidator(); 
$PasswordValidator->isCorrect($errorState);

echo $EmailValidator->getError();
echo $PasswordValidator->getError();