Validación de objetos PHP

Question

Actualmente estoy trabajando en una aplicación PHP OO. Tengo una clase llamada validación que me gustaría usar para verificar que todos los datos enviados sean válidos, sin embargo, obviamente necesito un lugar para definir las reglas para cada propiedad que se va a verificar. Por el momento, estoy usando matrices durante la construcción de un nuevo objeto. por ejemplo:

$this->name = array(
'maxlength' => 10, 
'minlength' => 2, 
'required' => true, 
'value' => $namefromparameter 
) 

Una matriz para cada propiedad.

Llamaría entonces a un método estático de la clase de validación que realizaría varias comprobaciones según los valores definidos en cada conjunto.

¿Hay una manera más eficiente de hacer esto? Cualquier consejo apreciado. Gracias.

Answer 1

Sé que la matriz asociativa se utiliza comúnmente para configurar cosas en PHP (se llama magic container patrón y se considera una mala práctica, por cierto), pero ¿por qué no crear varias clases de validador, cada uno de los cuales puede manejar uno ¿regla? Algo como esto:

interface IValidator { 
    public function validate($value); 
} 

$validators[] = new StringLengthValidator(2, 10); 
$validators[] = new NotNollValidator(); 
$validators[] = new UsernameDoesNotExistValidator(); 

Esto tiene múltiples ventajas sobre la puesta en práctica utilizando matrices:

• Puede documento ellos (muy importante), phpdoc no puede analizar los comentarios de claves de matriz.
• Su código se convierte en error tipográfico-safe (array('reqiured' => true))
• Es totalmente OO y no introduce nuevos conceptos
• Es más fácil de leer (aunque mucho más detallado)
• La implementación de cada restricción se puede encontrar de forma intuitiva (que no está en función de 400 líneas, pero en la clase apropiada)

EDITAR: Aquí está una link to an answer I gave a un different question, pero que es sobre todo aplicable a éste a su vez.

Answer 2

Desde el uso de OO, sería más claro si utilizó clases para validar propiedades. P.ej.

class StringProperty 
{ 
    public $maxLength; 
    public $minlength; 
    public $required; 
    public $value; 
    function __construct($value,$maxLength,$minLength,$required) 
    { 
    $this->value = $value; 
    $this-> maxLength = $maxLength; 
    $this-> minLength = $minLength; 
    $this-> required = $required; 
    } 
    function isValidat() 
    { 
    // Check if it is valid 
    } 
    function getValidationErrorMessage() 
    { 
    } 
} 

$this->name = new StringProperty($namefromparameter,10,2,true); 
if(!$this->name->isValid()) 
{ 
    $validationMessage = $this->name-getValidationErrorMessage(); 
} 

El uso de una clase tiene la ventaja de encapsular la lógica dentro de ella que la matriz (básicamente una estructura) no tiene.

Answer 3

Quizás se inspire en Zend-Framework Validation.

Así definir un maestro:

class BaseValidator { 
    protected $msgs = array(); 
    protected $params = array();  

    abstract function isValid($value); 
    public function __CONSTRUCT($_params) { 
     $this->params = $_params; 
    } 
    public function getMessages() { 
     // returns errors-messages 
     return $this->msgs; 
    } 
} 

y luego construir sus validadores personalizados:

class EmailValidator extends BaseValidator { 
    public function isValid($val=null) { 
     // if no value set use the params['value'] 
     if ($val==null) { 
      $val = $this->params['value']; 
     } 
     // validate the value 
     if (strlen($val) < $this->params['maxlength']) { 
      $this->msgs[] = 'Length too short'; 
     } 
     return count($this->msgs) > 0 ? false : true; 
    } 
} 

Por último la matriz de la inicial podría llegar a ser algo así como:

$this->name = new EmailValidator(
     array(
      'maxlength' => 10, 
      'minlength' => 2, 
      'required' => true, 
      'value' => $namefromparameter, 
     ), 
    ), 
); 

validación podría ser entonces hecho de esta manera:

if ($this->name->isValid()) { 
    echo 'everything fine'; 
} else { 
    echo 'Error: '.implode('<br/>', $this->name->getMessages()); 
}