El siguiente ejemplo demuestra cómo podría escribirse un sencillo validador personalizado. En este caso las reglas de validación son simplemente que el valor de entrada debe ser de punto flotante.

class MyValid_Float extends Zend_Validate_Abstract
{
    const FLOAT = 'float';

    protected $_messageTemplates = array(
        self::FLOAT => "'%value%' no es un valor de punto flotante"
    );

    public function isValid($value)
    {
        $this->_setValue($value);

        if (!is_float($value)) {
            $this->_error();
            return false;
        }

        return true;
    }
}

La clase define una plantilla para su único mensaje de fallo de validación, que incluye el mágico parámetro %value% . La llamada a _setValue() prepara al objeto para insertar automáticamente en el mensaje de fallo al valor probado, si éste falla en la validación. La llamada a _error() sigue las pistas para establecer una razón por el fracaso de la validación. Dado que esta clase sólo define un mensaje de fallo, no es necesario darle a _error() el nombre de la plantilla del mensaje de fallo.

El siguiente ejemplo muestra un conjunto de reglas de validación más complejo, donde es necesario que el valor de entrada ser numérico y dentro del límite de un rango de valores mínimos y máximos. Un valor de entrada podría fallar en la validación exactamente por una de las siguientes razones:

Estas razones en el fallo de validación, son traducidas a las definiciones en la clase:

class MyValid_NumericBetween extends Zend_Validate_Abstract
{
    const MSG_NUMERIC = 'msgNumeric';
    const MSG_MINIMUM = 'msgMinimum';
    const MSG_MAXIMUM = 'msgMaximum';

    public $minimum = 0;
    public $maximum = 100;

    protected $_messageVariables = array(
        'min' => 'minimum',
        'max' => 'maximum'
    );

    protected $_messageTemplates = array(
        self::MSG_NUMERIC => "'%value%' no es numérico",
        self::MSG_MINIMUM => "'%value%' debe ser al menos '%min%'",
        self::MSG_MAXIMUM => "'%value%' debe ser no mayor a '%max%'"
    );

    public function isValid($value)
    {
        $this->_setValue($value);

        if (!is_numeric($value)) {
            $this->_error(self::MSG_NUMERIC);
            return false;
        }

        if ($value < $this->minimum) {
            $this->_error(self::MSG_MINIMUM);
            return false;
        }

        if ($value > $this->maximum) {
            $this->_error(self::MSG_MAXIMUM);
            return false;
        }

        return true;
    }
}

Las propiedades públicas $minimum y $maximum se han establecido para proporcionar los límites mínimo y máximo, respectivamente, de un valor a validar. La clase también define dos variables de mensajes que corresponden a las propiedades públicas y permiten usar min y max en plantillas de mensajes como parámetros mágicos, al igual que con value .

Tenga en cuenta que si cualquiera de las comprobaciones de validación falla en isValid() , ya está preparado un mensaje apropiado, y el método inmediatamente devuelve FALSE . Estas reglas de validación son por lo tanto secuencialmente dependientes. Es decir, si uno de los tests falla, no hay necesidad de poner a prueba las posteriores reglas de validación. Sin embargo, esta necesidad no será el caso. El siguiente ejemplo ilustra cómo escribir una clase con reglas de validación independientes, donde el objeto validación puede devolver múltiples razones por las cuales fracasó un intento de validación en particular.

Considere escribir una clase de validación y control de contraseñas - cuando es necesario que un usuario elija una contraseña que cumple determinados criterios para ayudar a tener cuentas de usuario seguras. Supongamos que la seguridad de la contraseña aplica criterios que fuerzan a lo siguiente:

La siguiente clase implementa estos criterios de validación:

class MyValid_PasswordStrength extends Zend_Validate_Abstract
{
    const LENGTH = 'length';
    const UPPER  = 'upper';
    const LOWER  = 'lower';
    const DIGIT  = 'digit';

    protected $_messageTemplates = array(
        self::LENGTH => "'%value%' debe tener al menos una longitud de 8 caracteres",
        self::UPPER  => "'%value%' debe contener al menos una letra en mayúscula",
        self::LOWER  => "'%value%' debe contener al menos una letra en minúscula",
        self::DIGIT  => "'%value%' debe contener al menos un dígito"
    );

    public function isValid($value)
    {
        $this->_setValue($value);

        $isValid = true;

        if (strlen($value) < 8) {
            $this->_error(self::LENGTH);
            $isValid = false;
        }

        if (!preg_match('/[A-Z]/', $value)) {
            $this->_error(self::UPPER);
            $isValid = false;
        }

        if (!preg_match('/[a-z]/', $value)) {
            $this->_error(self::LOWER);
            $isValid = false;
        }

        if (!preg_match('/\d/', $value)) {
            $this->_error(self::DIGIT);
            $isValid = false;
        }

        return $isValid;
    }
}

Las cuatro pruebas de criterio en isValid() no devuelven inmediatamente FALSE . Esto permite a la clase de validación a proporcionar todas las razones por las que la contraseña de entrada no cumplió los requisitos de validación. Si, por ejemplo, un usuario ingresara el string " #$% " como contraseña, isValid() causaría que los cuatro mensajes de fracaso de validación sean devueltos por un llamado posterior a getMessages() .