Das folgende Beispiel demonstriert wie ein sehr einfacher eigener Prüfer geschrieben werden könnte. In diesem Fall sind die Prüfregeln sehr einfach und der Eingabewert muß ein Gleitkommawert sein.

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

    protected $_messageTemplates = array(
        self::FLOAT => "'%value%' ist kein Gleitkommawert"
    );

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

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

        return true;
    }
}

Die Klasse definiert ein Template für Ihre einzige Nachricht bei Prüfungsfehlern, welche den eingebauten magischen Parameter %value% inkludiert. Der Aufruf von _setValue() präpariert das Objekt den getesteten Wert automatisch in die Fehlernachricht einzufügen, wenn die Prüfung des Wertes fehlschlägt. Der Aufruf von _error() spürt den Grund für die fehlgeschlagene Prüfung auf. Da diese Klasse nur eine Fehlernachricht definiert, ist es nicht notwendig _error() den Namen des Templates der Fehlernachricht zu geben.

Das folgende Beispiel demonstriert ein komplexeres Set von Prüfregeln, wobei es notwendig ist das der Eingabewert nummerisch und innerhalb eines Bereiches von Mindest- und Maximalgrenzwerten ist. Bei einem Eingabewert würde die Prüfung wegen exakt einer der folgenden Gründe fehlschlagen:

Diese Gründe für fehlgeschlagene Prüfungen werden in Definitionen der Klasse übersetzt:

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%' ist nicht nummerisch",
        self::MSG_MINIMUM => "'%value%' muß mindestens '%min%' sein",
        self::MSG_MAXIMUM => "'%value%' darf nicht mehr als '%max%' sein"
    );

    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;
    }
}

Die öffentlichen Eigenschaften $minimum und $maximum wurden eingeführt um die Mindest- und Maximalgrenzen anzubieten, beziehungsweise, für einen Wert um die Prüfung erfolgreich zu bestehen. Die Klasse definiert auch zwei Nachrichtenvariablen die zu den öffentlichen Eigenschaften korrespondieren und es erlauben min und max in den Nachrichten Templates als magische Parameter zu verwenden, genauso wie value.

Zu beachten ist, das wenn eine der Prüfungen in isValid() fehlschlägt, eine entsprechende Fehlernachricht vorbereitet wird, und die Methode sofort FALSE zurückgibt. Diese Prüfregeln sind deswegen sequentiell abhängig. Das bedeuted, wenn einer der Tests fehlschlägt, gibt es keinen Grund eine weitere nachfolgende Prüfregel zu testen. Das muß aber trotzdem nicht der Fall sein. Das folgende Beispiel zeigt wie man eine Klasse schreiben kann die unabhängige Prüfregeln besitzt, wo die Prüfobjekte mehrfache Gründe zurückgeben könnten, warum ein spezieller Prüfversuch fehlgeschlagen ist.

Angenommen es wird eine Prüfklasse geschrieben für das Erzwingen von Passwortstärke - wenn ein Benutzer ein Passwort auswählen muß das diversen Kriterien entspricht um zu Helfen das die Benutzerzugänge sicher sind. Angenommen die Passwort Sicherheitskriterien erzwingen das folgende Passwort:

Die folgende Klasse impementiert diese Prüfkriterien:

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%' muß mindestens 8 Zeichen lang sein",
        self::UPPER  => "'%value%' muß mindestens ein großgeschriebenes "
                      . "Zeichen enthalten",
        self::LOWER  => "'%value%' muß mindestens ein kleingeschriebenes "
                      . "Zeichen enthalten",
        self::DIGIT  => "'%value%' muß mindestens eine Ziffer enthalten"
    );

    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;
    }
}

Zu beachten ist das diese vier Testkriterien in isValid() nicht sofort FALSE zurückgeben. Das erlaubt der Prüfklasse alle Gründe anzubieten bei denen das Eingabepasswort den Prüfvoraussetzungen nicht entsprochen hat. Wenn, zum Beispiel, ein Benutzer den String "#$%" als Passwort angegeben hat, würde isValid() alle vier Prüfungfehlermeldungen zurückgeben bei einen nachfolgenden Aufruf von getMessages().