Die folgenden Optionen werden von Zend_Validate_Alnum unterstützt:

Das folgende ist ein Standardbeispiel:

$validator = new Zend_Validate_Alnum();
if ($validator->isValid('Abcd12')) {
    // Der Wert enthält nur erlaubte Zeichen
} else {
    // false
}

Standardmäßig werden Leerzeichen nicht akzeptiert weil Sie nicht Teil des Alphabeths sind. Trotzdem gibt es einen Weg Sie als Eingabe zu akzeptieren. Das erlaubt es komplette Sätze oder Phrasen zu prüfen.

Um die Verwendung von Leerzeichen zu erlauben muss man die Option allowWhiteSpace angeben. Das kann während der Erstellung einer Instanz des Prüfers getan werden, oder im Nachhinein indem setAllowWhiteSpace() verwendet wird. Um den aktuellen Zustand zu erhalten kann getAllowWhiteSpace() verwendet werden.

$validator = new Zend_Validate_Alnum(array('allowWhiteSpace' => true));
if ($validator->isValid('Abcd und 12')) {
    // Der Wert enthält nur erlaubte Zeichen
} else {
    // false
}

Wenn Zend_Validate_Alnum verwendet wird dann wird jene Sprache verwendet, welche der Benutzer in seinem Browser gesetzt hat, um die erlaubten Zeichen zu setzen. Das bedeutet, wenn ein Benutzer de für Deutsch setzt dann kann er auch Zeichen wie ä, ö und ü zusätzlich zu den Zeichen des englischen Alphabeths setzen.

Welche Zeichen erlaubt sind hängt komplett von der verwendeten Sprache ab, da jede Sprache Ihr eigenes Set von Zeichen definiert.

Es gibt aktuell 3 Sprachen welche nicht mit Ihrer eigenen Schreibweise akzeptiert werden. Diese Sprachen sind koreanisch, japanisch und chinesisch, da diese Sprachen ein Alphabeth verwenden bei dem einzelne Zeichen so aufgebaut werden dass Sie mehrere Zeichen verwenden.

Im Falle das diese Sprachen verwendet werden wird der Inhalt nur durch Verwendung des englischen Alphabeths geprüft.

Die folgenden Optionen werden von Zend_Validate_Alpha unterstützt:

Das folgende ist ein standardmäßiges Beispiel:

$validator = new Zend_Validate_Alpha();
if ($validator->isValid('Abcd')) {
    // Der Wert enthält nur erlaubte Zeichen
} else {
    // false
}

Standardmäßig werden Leerzeichen nicht akzeptiert weil Sie nicht Teil des Alphabeths sind. Trotzdem gibt es einen Weg Sie als Eingabe zu akzeptieren. Das erlaubt es komplette Sätze oder Phrasen zu prüfen.

Um die Verwendung von Leerzeichen zu erlauben muss man die Option allowWhiteSpace angeben. Das kann während der Erstellung einer Instanz des Prüfers getan werden, oder im Nachhinein indem setAllowWhiteSpace() verwendet wird. Um den aktuellen Zustand zu erhalten kann getAllowWhiteSpace() verwendet werden.

$validator = new Zend_Validate_Alpha(array('allowWhiteSpace' => true));
if ($validator->isValid('Abcd and efg')) {
    // Der Wert enthält nur erlaubte Zeichen
} else {
    // false
}

Wenn Zend_Validate_Alpha verwendet wird dann wird jene Sprache verwendet, welche der Benutzer in seinem Browser gesetzt hat, um die erlaubten Zeichen zu setzen. Das bedeutet, wenn ein Benutzer de für Deutsch setzt dann kann er auch Zeichen wie ä, ö und ü zusätzlich zu den Zeichen des englischen Alphabeths setzen.

Welche Zeichen erlaubt sind hängt komplett von der verwendeten Sprache ab, da jede Sprache Ihr eigenes Set von Zeichen definiert.

Es gibt aktuell 3 Sprachen welche nicht mit Ihrer eigenen Schreibweise akzeptiert werden. Diese Sprachen sind koreanisch, japanisch und chinesisch, da diese Sprachen ein Alphabeth verwenden bei dem einzelne Zeichen so aufgebaut werden dass Sie mehrere Zeichen verwenden.

Im Falle das diese Sprachen verwendet werden wird der Inhalt nur durch Verwendung des englischen Alphabeths geprüft.

Die folgenden Optionen werden für Zend_Validate_Barcode unterstützt:

Um zu prüfen ob ein angegebener String ein Barcode ist muss man nur dessen Typ wissen. Siehe das folgende Beispiel für einen EAN13 Barcode:

$valid = new Zend_Validate_Barcode('EAN13');
if ($valid->isValid($input)) {
    // Die Eingabe scheint gültig zu sein
} else {
    // Die Eingabe ist ungültig
}

Einige Barcodes können mit einer optionalen Checksumme angegeben werden. Diese Barcodes würden gültig sein, selbst ohne Checksumme. Trotzdem, wenn eine Checksumme angegeben wird, dann sollte man Sie auch prüfen. Standardmäßig führen diese Barcode Typen keine Prüfung der Checksumme durch. Durch Verwendung der Option checksum kann man definieren ob die Checksumme geprüft oder ignoriert wird.

$valid = new Zend_Validate_Barcode(array(
    'adapter'  => 'EAN13',
    'checksum' => false,
));
if ($valid->isValid($input)) {
    // Die Eingabe scheint gültig zu sein
} else {
    // Die Eingabe ist ungültig
}

Man kann eigene Barcode Prüfungen für die Verwendung mit Zend_Validate_Barcode schreiben; das ist oft notwendig wenn man mit proprietären Barcodes arbeiten muss. Um eine eigene Barcode Prüfung zu schreiben benötigt man die folgenden Informationen.

Die eigene Barcode Prüfung muss Zend_Validate_Barcode_AdapterAbstract erweitern oder Zend_Validate_Barcode_AdapterInterface implementieren.

Als Beispiel, erstellen wir eine Prüfung welche eine gerade Anzahl an Zeichen erwartet welche alle Ziffern und die Zeichen 'ABCDE' enthalten kann, und die eine Checksumme benötigt.

class My_Barcode_MyBar extends Zend_Validate_Barcode_AdapterAbstract
{
    protected $_length     = 'even';
    protected $_characters = '0123456789ABCDE';
    protected $_checksum   = '_mod66';

    protected function _mod66($barcode)
    {
        // Mach einige Prüfungen und gib ein Boolean zurück
    }
}

$valid = new Zend_Validate_Barcode('My_Barcode_MyBar');
if ($valid->isValid($input)) {
    // Die Eingabe scheint gültig zu sein
} else {
    // Die Eingabe ist ungültig
}

Die folgenden Optionen werden für Zend_Validate_Between unterstützt:

Standardmäßig prüft diese Prüfung ob ein Wert zwischen min und max liegt wobei beide Grenzwerte als Wert erlaubt sind.

$valid  = new Zend_Validate_Between(array('min' => 0, 'max' => 10));
$value  = 10;
$result = $valid->isValid($value);
// Gibt true zurück

Im oben stehenden Beispiel ist das Ergebnis TRUE da die Suche standardmäßig inklusive den Grenzwerten stattfindet. Das bedeutet in unserem Fall das jeder Wert zwischen '0' und '10' erlaubt ist. Und Werte wie '-1' und '11' geben FALSE zurück.

Manchmal ist es nützlich einen Wert zu prüfen wobei die Grenzwerte exkludiert werden. Siehe das folgende Beispiel:

$valid  = new Zend_Validate_Between(
    array(
        'min' => 0,
        'max' => 10,
        'inclusive' => false
    )
);
$value  = 10;
$result = $valid->isValid($value);
// Gibt false zurück

Das Beispiel ist fast so ähnlich wie unser erstes Beispiel, aber wir haben die Grenzwerte ausgeschlossen. Jetzt sind die Werte '0' und '10' nicht mehr erlaubt und geben FALSE zurück.

Die folgenden Optionen werden für Zend_Validate_Callback unterstützt:

Der einfachste Anwendungsfall besteht darin eine einzelne Funktion zu haben und diese als Callback zu verwenden. Angenommen wir haben die folgende Funktion.

function myMethod($value)
{
    // einige Prüfungen
    return true;
}

Um diese in Zend_Validate_Callback zu verwenden muss man Sie nur auf folgende Weise aufrufen:

$valid = new Zend_Validate_Callback('myMethod');
if ($valid->isValid($input)) {
    // Input scheint gültig zu sein
} else {
    // Input ist ungültig
}

PHP 5.3 führt Closures ein, welche grundsätzlich selbst-enthaltene oder anonyme Funktionen sind. PHP nimmt an das Closures eine andere Form eines Callbacks sind, und können daher als solche mit Zend_Validate_Callback verwendet werden. Als Beispiel:

$valid = new Zend_Validate_Callback(function($value){
    // einige Prüfungen
    return true;
});

if ($valid->isValid($input)) {
    // Input scheint gültig zu sein
} else {
    // Input ist ungültig
}

Natürlich ist es auch möglich eine Klassenmethode als Callback zu verwenden. Angenommen wir haben die folgende Klassenmethode:

class MyClass
{
    public function myMethod($value)
    {
        // einige Prüfungen
        return true;
    }
}

Die Definition des Callbacks ist in diesem Fall fast die gleiche. Man muss nur eine Instanz der Klasse vor der Methode erstellen und ein Array das den Callback beschreibt:

$object = new MyClass;
$valid = new Zend_Validate_Callback(array($object, 'myMethod'));
if ($valid->isValid($input)) {
    // Input scheint gültig zu sein
} else {
    // Input ist ungültig
}

Man kann auch eine statische Methode als Callback definieren. Angenommen wir haben die folgende Klassendefinition dann ist die Verwendung des Prüfers wie folgt:

class MyClass
{
    public static function test($value)
    {
        // Einige Prüfungen
        return true;
    }
}

$valid = new Zend_Validate_Callback(array('MyClass', 'test'));
if ($valid->isValid($input)) {
    // Input scheint gültig zu sein
} else {
    // Input ist ungültig
}

Letztendlich kann man, wenn man PHP 5.3 verwendet, die magische Methode __invoke() in der eigenen Klasse definieren. Wenn man das tut dann funktioniert die Angabe einer Instanz der Klasse genauso:

class MyClass
{
    public function __invoke($value)
    {
        // some validation
        return true;
    }
}

$object = new MyClass();
$valid = new Zend_Validate_Callback($object);
if ($valid->isValid($input)) {
    // Input scheint gültig zu sein
} else {
    // Input ist ungültig
}

Zend_Validate_Callback erlaubt auch die Verwendung von Optionen welche als zusätzliche Argumente dem Callback übergeben werden.

Nehmen wir die folgende Klassen und Methoden Definition an:

class MyClass
{
    function myMethod($value, $option)
    {
        // einige Prüfungen
        return true;
    }
}

Es gibt zwei Wege um den Prüfer über zusätzliche Optionen zu informieren: Diese im Constructor übergeben, oder Sie mit der Methode setOptions() übergeben.

Um Sie im Contructor zu übergeben, muss ein Array übergeben werden das die zwei Schlüssel "callback" und "options" enthält:

$valid = new Zend_Validate_Callback(array(
    'callback' => array('MyClass', 'myMethod'),
    'options'  => $option,
));

if ($valid->isValid($input)) {
    // Input scheint gültig zu sein
} else {
    // Input ist ungültig
}

Andererseits können Sie dem Prüfer auch nach der Instanzierung übergeben werden:

$valid = new Zend_Validate_Callback(array('MyClass', 'myMethod'));
$valid->setOptions($option);

if ($valid->isValid($input)) {
    // Input scheint gültig zu sein
} else {
    // Input ist ungültig
}

Wenn zusätzliche Werte an isValid() übergeben werden, dann werden diese Werte unmittelbar nach $value hinzugefügt.

$valid = new Zend_Validate_Callback(array('MyClass', 'myMethod'));
$valid->setOptions($option);

if ($valid->isValid($input, $additional)) {
    // Input scheint gültig zu sein
} else {
    // Input ist ungültig
}

Wenn der Aufruf zu einem Callback durchgeführt wird, dann wird der Wert der zu überprüfen ist als erstes Argument an den Callback übergeben gefolgt von allen anderen Werten die an isValid() übergeben wurden; alle anderen Optionen folgen Ihm. Die Anzahl und der Typ der Optionen welche verwendet werden ist nicht limitiert.

Die folgenden Optionen werden für Zend_Validate_CreditCard unterstützt:

Es gibt verschiedene Kreditkarten Institute wie mit Zend_Validate_CreditCard geprüft werden können. Standardmäßig werden alle bekannte Institute akzeptiert. Siehe das folgende Beispiel:

$valid = new Zend_Validate_CreditCard();
if ($valid->isValid($input)) {
    // Die Eingabe scheint gültig zu sein
} else {
    // Die Eingabe ist ungültig
}

Das oben stehende Beispiel würde alle bekannten Kreditkarten Institute als gültig erkennen.

Manchmal ist es notwendig nur definierte Kreditkarten Institute zu akzeptieren statt alle; z.B wenn man einen Webshop hat der nur Visa und American Express Karten akzeptiert. Zend_Validate_CreditCard erlaubt einem exakt das zu tun, indem auf genau diese Institute limitiert wird.

Um ein Limit zu verwenden kann man entweder spezifische Institute bei der Initiierung angeben, oder im nachhinein durch Verwendung von setType(). Jede kann verschiedene Argumente verwenden.

Man kann ein einzelnes Institut angeben:

$valid = new Zend_Validate_CreditCard(
    Zend_Validate_CreditCard::AMERICAN_EXPRESS
);

Wenn man mehrere Institute erlauben will, dann kann man diese als Array angeben:

$valid = new Zend_Validate_CreditCard(array(
    Zend_Validate_CreditCard::AMERICAN_EXPRESS,
    Zend_Validate_CreditCard::VISA
));

Wie bei allen Prüfern kann man auch ein assoziatives Array an Optionen oder eine Instanz von Zend_Config angeben. In diesem Fall muß man die Institute mit dem Arrayschlüssel type angeben wie hier simuliert:

$valid = new Zend_Validate_CreditCard(array(
    'type' => array(Zend_Validate_CreditCard::AMERICAN_EXPRESS)
));

Man kann Institute auch im Nachhinein setzen oder hinzufügen indem die Methoden setType(), addType() und getType() verwendet werden.

$valid = new Zend_Validate_CreditCard();
$valid->setType(array(
    Zend_Validate_CreditCard::AMERICAN_EXPRESS,
    Zend_Validate_CreditCard::VISA
));

Wie vorher erwähnt prüft Zend_Validate_CreditCard nur die Kreditkarten Nummer. Glücklicherweise bieten einige Institute online APIs welche eine Kreditkarten Nummer durch Verwendung von Algorithmen prüfen kann, welche nicht öffentlich bekannt sind. Die meisten dieser Services sind zu bezahlen. Deshalb ist diese Art der Prüfung standardmäßig deaktiviert.

Wenn man auf so eine API zugreift, kann man diese als Addon für Zend_Validate_CreditCard verwenden um die Sicherheit der Prüfung zu erhöhen.

Um das zu tun muss man einfach einen Callback angeben der aufgerufen wird wenn die generische Prüfung erfolgreich war. Das verhindert das die API für ungültige Nummern aufgerufen wird, was wiederum die Performance der Anwendung erhöht.

setService() setzt ein neues Service und getService() gibt das gesetzte Service zurück. Als Option für die Konfiguration kann man den Arrayschlüssel 'service' bei der Initiierung verwenden. Für Details über mögliche Optionen kann man unter Callback nachsehen.

// Die eigene Service Klasse
class CcService
{
    public function checkOnline($cardnumber, $types)
    {
        // einige online Prüfungen
    }
}

// Die Prüfung
$service = new CcService();
$valid   = new Zend_Validate_CreditCard(Zend_Validate_CreditCard::VISA);
$valid->setService(array($service, 'checkOnline'));

Wie man sieht wird die Callback Methode mit der Kreditkarten Nummer als erster Parameter aufgerufen, und die akzeptierten Typen als zweiter Parameter.

Die folgenden Optionen werden für Zend_Validate_Date unterstützt:

Der einfachste Weg um ein Datum zu prüfen ist die Verwendung des Standardmäßigen Datumsformats. Dieses wird verwendet wenn kein Gebietsschema und kein Format angegeben werden.

$validator = new Zend_Validate_Date();

$validator->isValid('2000-10-10');   // Gibt true zurück
$validator->isValid('10.10.2000'); // Gibt false zurück

Das standardmäßige Datumsformat für Zend_Validate_Date ist 'yyyy-MM-dd'.

Zend_Validate_Date prüft auch Daten welche in einem lokalisierten Format angegeben werden. Durch Verwendung der Option locale kann das Gebietsschema definiert werden von dem das Datumsformat für die Prüfung verwendet werden soll.

$validator = new Zend_Validate_Date(array('locale' => 'de'));

$validator->isValid('10.Feb.2010'); // Gibt true zurück
$validator->isValid('10.May.2010'); // Gibt false zurück

Die Option locale setzt das standardmäßige Datumsformat. Im obigen Beispiel ist dies 'dd.MM.yyyy' welches als Standardmäßige Datumsformat für 'de' definiert ist.

Zend_Validate_Date unterstützt auch selbst definierte Datumsformate. Wenn man solch ein Datum prüfen will muss man die Option format verwenden.

$validator = new Zend_Validate_Date(array('format' => 'yyyy'));

$validator->isValid('2010'); // Gibt true zurück
$validator->isValid('May');  // Gibt false zurück

Natürlich kann man format und locale kombinieren. In diesem Fall kann man lokalisierte Monats- oder Tagesnamen verwenden.

$validator = new Zend_Validate_Date(array('format' => 'yyyy MMMM', 'locale' => 'de'));

$validator->isValid('2010 Dezember'); // Gibt true zurück
$validator->isValid('2010 June');     // Gibt false zurück

Die folgenden Optionen werden für Zend_Validate_Db_NoRecordExists und Zend_Validate_Db_RecordExists unterstützt:

Ein Beispiel der rundsätzlichen Verwendung der Validatoren:

// Prüft ob die Email Adresse in der Datenbank existiert
$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table' => 'users',
        'field' => 'emailaddress'
    )
);

if ($validator->isValid($emailaddress)) {
    // Die Email Adresse scheint gültig zu sein
} else {
    // Die Email Adresse ist ungültig; gib die Gründe an
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

Das oben stehende testet ob eine gegebene Email Adresse in der Datenbanktabelle vorhanden ist. Wenn kein Eintrag gefunden wird der den Wert von $emailaddress in der spezifizierten Spalte hat, wird eine Fehlermeldung angezeigt.

// Prüft ob der Benutzername in der Datenbank existiert
$validator = new Zend_Validate_Db_NoRecordExists(
    array(
        'table' => 'users',
        'field' => 'username'
    )
);
if ($validator->isValid($username)) {
    // Der Benutzername scheint gültig zu sein
} else {
    // Der Benutzername ist ungültig; gib die Gründe an
    $messages = $validator->getMessages();
    foreach ($messages as $message) {
        echo "$message\n";
    }
}

Das oben stehende testet ob ein angegebener Benutzername nicht in der Datenbanktabelle vorhanden ist. Wenn ein Eintrag gefunden wird, der den der von $username in der spezifizierten Spalte enthält, dann wird eine Fehlermeldung angezeigt.

Zend_Validate_Db_RecordExists und Zend_Validate_Db_NoRecordExists bieten auch die Möglichkeit die Datenbank zu testen, wobei Teile der Tabelle hiervon ausgenommen werden, entweder indem eine where Klausel als String angegeben wird, oder ein Array mit den Schlüsseln "field" und "value".

Wenn ein Array für die Ausnahmeklausel angegeben wird, dann wird der != Operator verwenden. Damit kann der Rest einer Tabelle auf einen Wert geprüft werden bevor ein Eintrag geändert wird (zum Beispiel in einem Formular für ein Benutzerprofil).

// Prüft ob kein anderer Benutzer diesen Benutzernamen hat
$user_id   = $user->getId();
$validator = new Zend_Validate_Db_NoRecordExists(
    array(
        'table'   => 'users',
        'field'   => 'username',
        'exclude' => array(
            'field' => 'id',
            'value' => $user_id
        )
    )
);

if ($validator->isValid($username)) {
    // Der Benutzername scheint gültig zu sein
} else {
    // Der Benutzername ist ungültig; zeige den Grund
    $messages = $validator->getMessages();
    foreach ($messages as $message) {
        echo "$message\n";
    }
}

Das obige Beispiel prüft die Tabelle um sicherzustellen das keine anderen Einträge existieren bei denen id = $user_id als Wert $username enthalten.

Man kann auch einen String an die Ausnahmeklausel angeben damit man einen anderen Operator als != verwenden kann. Das kann nützlich sein um bei geteilten Schlüsseln zu testen.

$post_id   = $post->getId();
$clause    = $db->quoteInto('post_id = ?', $category_id);
$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table'   => 'posts_categories',
        'field'   => 'post_id',
        'exclude' => $clause
);

if ($validator->isValid($username)) {
    // Der Benutzername scheint gültig zu sein
} else {
    // Der Benutzername ist ungültig; die Gründe ausgeben
    $messages = $validator->getMessages();
    foreach ($messages as $message) {
        echo "$message\n";
    }
}

Das obige Beispiel prüft die Tabelle 'posts_categories' und stellt sicher das ein Eintrag der 'post_id' einen Wert hat der $category_id entspricht.

Man kann auch einen Adapter spezifizieren wenn man die Prüfung instanziiert. Das erlaubt es mit Anwendungen zu arbeiten die mehrere Datenbankadapter verwenden, oder wo kein Standardadapter gesetzt wird. Als Beispiel:

$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table'   => 'users',
        'field'   => 'id',
        'adapter' => $dbAdapter
    )
);

Man kann für die eigene Datenbank bei Adaptern wie PostgreSQL und DB/2 ein Schema spezifizieren indem einfach ein Array mit den Schlüsseln table und schema angegeben wird. Anbei ein Beispiel:

$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table'  => 'users',
        'schema' => 'my',
        'field'  => 'id'
    )
);

Es gibt keine zusätzlichen Optionen für Zend_Validate_Digits:

Um zu prüfen ob ein angegebener Wert nur Ziffern und keine anderen Zeichen enthält, muss die Prüfung einfach wie in diesem Beispiel gezeigt aufgerufen werden:

$validator = new Zend_Validate_Digits();

$validator->isValid("1234567890"); // Gibt true zurück
$validator->isValid(1234);         // Gibt true zurück
$validator->isValid('1a234');      // Gibt false zurück

Ein Beispiel einer normalen Benutzung ist anbei:

$validator = new Zend_Validate_EmailAddress();
if ($validator->isValid($email)) {
    // Email Adresse scheint gültig zu sein
} else {
    // Email Adresse ist ungültig, drucke die Gründe hierfür
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

Das prüft die Email Adresse $email und gibt bei einem Fehler über getMessages() eine nützliche Fehlermeldung aus.

Zend_Validate_EmailAddress unterstützt verschiedene Optionen welche entweder bei der Initiierung, durch Übergeben eines Arrays mit den betreffenden Optionen, gesetzt werden können, oder im Nachhinein, durch Verwendung von setOptions(). Die folgenden Optionen werden unterstützt:

$validator = new Zend_Validate_EmailAddress();
$validator->setOptions(array('domain' => false));

Zend_Validate_EmailAdress prüft jede gültige Email Adresse mit RFC2822. Gültige Email Adressen sind zum Beispiel bob@domain.com, bob+jones@domain.us, "bob@jones"@domain.com und "bob jones"@domain.com.

Einige Email Formate werden aktuell nicht geprüft (z.B. Zeilenumbruch Zeichen oder ein "\" Zeichen in einer Email Adresse).

Wenn man will das Zend_Validate_EmailAddress nur den lokalen Teil der Email Adresse prüfen soll, und die Prüfung des Hostnamens ausschalten will, kann man die domain Option auf FALSE setzen. Das zwingt Zend_Validate_EmailAddress den Hostname Teil der Email Adresse nicht zu prüfen.

$validator = new Zend_Validate_EmailAddress();
$validator->setOptions(array('domain' => FALSE));

Der Teil des Hostnamens einer Email Adresse wird mit Zend_Validate_Host geprüft. Standardmäßig werden nur DNS Hostnamen in der Form domain.com akzeptiert, aber wenn es gewünscht ist, können auch IP Adressen und lokale Hostnamen auch akzeptiert werden.

Um das zu tun, muß eine Zend_Validate_EmailAddress Instanz erstellt werden der ein Parameter übergeben wird, um den Typ des Hostnamens anzugeben der akzeptiert werden soll. Mehr Details sind in Zend_Validate_Hostname inkludiert, zusammen mit einem Beispiel, wie DNS und lokale Hostnamen, akzeptiert werden wie im Beispiel das anbei steht:

$validator = new Zend_Validate_EmailAddress(
                    Zend_Validate_Hostname::ALLOW_DNS |
                    Zend_Validate_Hostname::ALLOW_LOCAL);
if ($validator->isValid($email)) {
    // Email Adresse scheint gültig zu sein
} else {
    // Email ist ungültig; Gründe ausdrucken
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

Nur weil eine Email Adresse im richtigen Format ist, heißt das notwendigerweise nicht das die Email Adresse aktuell auch existiert. Um dieses Problem zu lösen, kann MX Prüfung verwendet werden um zu prüfen ob ein MX (Email) Eintrag im DNS Eintrag für den Hostnamen der Email existiert. Das zeigt ob der Hostname Emails akzeptiert, sagt aber nicht aus, ob die genaue Email Adresse selbst gültig ist.

Die MX Prüfung ist standardmäßig nicht eingeschaltet. Um die MX Prüfung einzuschalten kann ein zweiter Parameter an den Zend_Validate_EmailAddress Konstruktor übergeben werden.

$validator = new Zend_Validate_EmailAddress(
    array(
        'allow' => Zend_Validate_Hostname::ALLOW_DNS,
        'mx'    => true
    )
);

Alternativ kann entweder TRUE oder FALSE an setValidateMx() übergeben werden um die MX Prüfung ein- oder auszuschalten.

Durch das einschalten dieser Option werden Netzwerk Funktionen verwendet um zu Prüfen ob ein MX Eintrag am Hostnamen der Email Adresse existiert, welche geprüft werden soll. Vorsicht davor, das hierbei das eigene Skript langsamer wird.

Manchmal gibt die Prüfung auf MX Records FALSE zurück, selbst wenn Emails akzeptiert werden. Der Hintergrund dieses Verhaltens ist, das der Server Emails akzeptieren kann, selbst wenn er keinen MX Record anbietet. In diesem Fall kann er A, A6 oder AAAA Records anbieten. Um es Zend_Validate_EmailAddress zu erlauben auch auf diese anderen Records zu prüfen, muss man die tiefe MX Prüfung einschalten. Das kann man durch Setzen der deep Option bei der Initialisierung, oder durch Verwendung von setOptions() tun.

$validator = new Zend_Validate_EmailAddress(
    array(
        'allow' => Zend_Validate_Hostname::ALLOW_DNS,
        'mx'    => true,
        'deep'  => true
    )
);

Zend_Validate_EmailAddress prüft auch internationale Zeichen prüfen, die in einigen Domains existieren. Dies ist als Unterstützung für Internationale Domain Namen (IDN) bekannt. Standardmäßig ist das eingeschaltet. Das kann aber ausgeschaltet werden indem eine Einstellung geändert wird über das interne Zend_Validate_Hostname Objekt das innerhalb von Zend_Validate_EmailAddress existiert.

$validator->getHostnameValidator->setValidateIdn(false);

Weitere Informationen über die Verwendung von setValidateIdn() gibt es in der Zend_Validate_Hostname Dokumentation.

Es sollte darauf geachtet werden das IDNs nur geprüft werden wenn erlaubt ist DNS Hostnamen zu prüfen.

Standardmäßig wird ein Hostname mit einer List von bekannten TLDs geprüft. Das ist standardmäßig aktiviert, kann aber ausgeschaltet werden indem die Einstellung über das interne Zend_Validate_Hostname geändert wird, das innerhalb von Zend_Validate_EmailAddress existiert.

$validator->getHostnameValidator->setValidateTld(false);

Mehr Informationen über die Verwendung von setValidateTld() gibt es in der Zend_Validate_Hostname Dokumentation.

Es sollte darauf geachtet werden das TLDs nur geprüft werden wenn es auch erlaubt ist DNS Hostnamen zu prüfen.

Zend_Validate_EmailAddress verwendet auch Zend_Validate_Hostname um den Teil des Hostnamens einer angegebenen Email Adresse zu prüfen. Ab Zend Framework 1.10 kann man Meldungen für Zend_Validate_Hostname auch von innerhalb Zend_Validate_EmailAddress setzen.

$validator = new Zend_Validate_EmailAddress();
$validator->setMessages(array(
    Zend_Validate_Hostname::UNKNOWN_TLD => 'Ich kenne die TLD nicht')
);

Vor Zend Framework 1.10 musste man die Meldungen einem eigenen Zend_Validate_Hostname hinzufügen, und dann diese Prüfung in Zend_Validate_EmailAddress setzen um die eigenen Meldungen zurückzubekommen.

Die folgenden Optionen werden für Zend_Validate_Float unterstützt:

Der einfachste Weg eine Gleitkommazahl zu prüfen ist die Verwendung der Systemeinstellungen. Wenn keine Option verwendet wird, dann wird das Gebietsschema der Umgebung für die Prüfung verwendet:

$validator = new Zend_Validate_Float();

$validator->isValid(1234.5);   // Gibt true zurück
$validator->isValid('10a01'); // Gibt false zurück
$validator->isValid('1,234.5'); // Gibt true zurück

Im obigen Beispiel wird in der Umgebung das Gebietsschema "en" erwartet.

Oft ist es nützlich in der Lage zu sein lokalisierte Werte zu prüfen. Gleitkommazahlen werden in anderen Ländern oft unterschiedlich geschrieben. Wird zum Beispiel englisch verwendet wird "1.5" geschrieben. Im deutschen wird man "1,5" schreiben und in anderen Sprachen können Gruppierungen verwendet werden.

Zend_Validate_Float ist in der Lage solche Schreibweisen zu verwenden. Aber es ist auf das Gebietsschema begrenzt welches man verwendet. Siehe den folgenden Code:

$validator = new Zend_Validate_Float(array('locale' => 'de'));

$validator->isValid(1234.5); // Gibt true zurück
$validator->isValid("1 234,5"); // Gibt false zurück
$validator->isValid("1.234"); // Gibt true zurück

Bei Verwendung eines Gebietsschemas wird die Eingabe, wie man sehen kann lokalisiert geprüft. Bei Verwendung einer anderen Schreibweise erhält man ein FALSE wenn das Gebietsschema eine andere Schreibweise erzwingt.

Das Gebietsschema kann auch im Nachhinein gesetzt werden indem setLocale() verwendet wird, und empfangen indem man getLocale() verwendet.

Die folgenden Optionen werden von Zend_Validate_GreaterThan unterstützt:

Um zu prüfen ob ein angegebener Wert größer als eine definierte Grenze ist, kann einfach das folgende Beispiel verwendet werden.

$valid  = new Zend_Validate_GreaterThan(array('min' => 10));
$value  = 11;
$return = $valid->isValid($value);
// Gibt true zurück

Das obige Beispiel gibt für alle Werte TRUE zurück die größer als 10 sind.

$valid  = new Zend_Validate_GreaterThan(array('min' => 10));
$value  = 10;
$return = $valid->isValid($value);
// Gibt false zurück

Das obige Beispiel gibt für alle Werte FALSE zurück die kleiner oder gleich dem Grenzwert sind.

Es gibt keine zusätzlichen Optionen für Zend_Validate_Hex:

Die folgenden Optionen werden für Zend_Validate_Hostname unterstützt:

Normale Verwendung

$validator = new Zend_Validate_Hostname();
if ($validator->isValid($hostname)) {
    // Hostname scheint gültig zu sein
} else {
    // Hostname ist ungülig; Gründe dafür ausdrucken
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

Das prüft den Hostnamen $hostname und wird einen Fehler über getMessages() mit einer nützlichen Fehlermeldung auswerfen.

Es kann gewünscht sein auch IP Adressen, lokale Hostnamen, oder eine Kombination aller drei erlaubten Typen zu prüfen. Das kann gemacht werden durch die Übergabe eines Parameters an Zend_Validate_Hostname wenn dieser initialisiert wird. Der Parameter sollte ein Integer sein, welcher die Typen von Hostnamen auswählt die erlaubt sind. Hierfür können die Zend_Validate_Hostname Konstanten verwendet werden.

Die Zend_Validate_Hostname Konstanten sind: ALLOW_DNS um nur DNS Hostnamen zu erlauben, ALLOW_IP um IP Adressen zu erlauben, ALLOW_LOCAL um lokale Hostnamen zu erlauben, und ALLOW_ALL um alle drei Typen zu erlauben. Um nur IP Adressen zu prüfen kann das folgende Beispiel verwendet werden:

$validator = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_IP);
if ($validator->isValid($hostname)) {
    // Hostname scheint gültig zu sein
} else {
    // Hostname ist ungülig; Gründe dafür ausdrucken
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

Genau wie die Verwendung von ALLOW_ALL alle Typen von Hostnamen akzeptiert, können diese Typen kombiniert werden um Kombinationen zu erlauben. Um zum Beispiel DNS und lokale Hostnamen zu akzeptieren muß das Zend_Validate_Hostname Objekt wie folgt initialisiert werden:

$validator = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_DNS |
                                        Zend_Validate_Hostname::ALLOW_IP);

Einige Länder Code Top Level Domains (ccTLDs), wie 'de' (Deutschland), unterstützen internationale Zeichen in Domain Namen. Diese sind als Internationale Domain Namen (IDN) bekannt. Diese Domains können mit Zend_Validate_Hostname geprüft werden, mit Hilfe von erweiterten Zeichen die im Prüfprozess verwendet werden.

Eine IDN Domain zu prüfen ist genauso einfach wie die Verwendung des standard Hostnamen Prüfers da IDN Prüfung standardmäßig eingeschaltet ist. Wenn IDN Prüfung ausgeschaltet werden soll, kann das entweder durch die Übergabe eines Parameters im Zend_Validate_Hostname Constructor, oder über die setValidateIdn() Methode gemacht werden.

Die IDN Prüfung kann ausgeschaltet werden durch die Übergabe eines zweiten Parameters an den Zend_Validate_Hostname Constructor auf die folgende Art und Weise.

$validator =
    new Zend_Validate_Hostname(
        array(
            'allow' => Zend_Validate_Hostname::ALLOW_DNS,
            'idn'   => false
        )
    );

Alternativ kann entweder TRUE oder FALSE an setValidateIdn() übergeben werden, um die IDN Prüfung ein- oder auszuschalten. Wenn ein IDN Hostname geprüft wird, der aktuell nicht unterstützt wird, ist sicher das die Prüfung fehlschlagen wird wenn er irgendwelche internationalen Zeichen hat. Wo keine ccTLD Datei in Zend/Validate/Hostname existiert, welche die zusätzlichen Zeichen definiert, wird eine normale Hostnamen Prüfung durchgeführt.

Normalerweise wird ein Hostname gegen eine Liste von bekannten TLDs geprüft. Wenn diese Funktionalität nicht benötigt wird kann das, auf die gleiche Art und Weise wie die IDN Unterstützung, ausgeschaltet werden Die TLD Prüfung kann ausgeschaltet werden indem ein dritter Parameter an den Zend_Validate_Hostname Constructor übergeben wird. Im folgenden Beispiel wird die IDN Prüfung durch den zweiten Parameter unterstützt.

$validator =
    new Zend_Validate_Hostname(
        array(
            'allow' => Zend_Validate_Hostname::ALLOW_DNS,
            'idn'   => true,
            'tld'   => false
        )
    );

Alternativ kann entweder TRUE oder FALSE übergeben an setValidateTld() übergeben werden um die TLD Prüfung ein- oder auszuschalten.

Die folgenden Optionen werden für Zend_Validate_Iban unterstützt:

IBAN Nummern sind immer in Bezug zu einem Land. Dies bedeutet dass unterschiedliche Länder unterschiedliche Formate für Ihre IBAN Nummern verwenden. Das ist der Grund dafür warum IBAN nummern immer ein Gebietsschema benötigen. Wenn wir dies wissen, dann wissen wir bereits wie wir Zend_Validate_Iban verwenden können.

// In der Bootstrap
Zend_Registry::set('Zend_Locale', new Zend_Locale('de_AT'));

// Im Modul
$validator = new Zend_Validate_Iban();

if ($validator->isValid('AT611904300234573201')) {
    // IBAN scheint gültig zu sein
} else {
    // IBAN ist ungültig
}

$validator = new Zend_Validate_Iban(array('locale' => false));
// Achtung: Man kann ein FALSE auch als einzelnen Parmeter setzen

if ($validator->isValid('AT611904300234573201')) {
    // IBAN scheint gültig zu sein
} else {
    // IBAN ist nicht gültig
}

$validator = new Zend_Validate_Iban(array('locale' => 'de_AT'));

if ($validator->isValid('AT611904300234573201')) {
    // IBAN scheint gültig zu sein
} else {
    // IBAN ist ungültig
}

Die folgenden Optionen werden für Zend_Validate_Identical unterstützt:

Um zu prüfen ob zwei Werte identisch sind muss man den originalen Wert als Vergleichswert setzen. Siehe das folgende Beispiel welches zwei Strings vergleicht.

$valid = new Zend_Validate_Identical('original');
if ($valid->isValid($value) {
    return true;
}

Die Prüfung wird nur dann TRUE zurückgeben wenn beide Werte 100% identisch sind. In unserem Beispiel wenn $value 'original' ist.

Man kann den gewünschten Token auch im Nachhinein durch Verwendung der Methode setToken() setzen und mit getToken() den aktuell gesetzten Token erhalten.

Natürlich kann Zend_Validate_Identical nicht nur Strings prüfen, sondern jeden Variablentyp wie Boolean, Integer, Float, Array oder sogar Objekte. Wie bereits notiert müssen Vergleichswert und Wert identisch sein.

$valid = new Zend_Validate_Identical(123);
if ($valid->isValid($input)) {
    // Der Wert scheint gültig zu sein
} else {
    // Der Wert ist ungültig
}

Zend_Validate_Identical unterstützt auch den Vergleich von Formularelementen. Das kann getan werden indem der Name des Elements als token verwendet wird. Siehe das folgende Beispiel:

$form->addElement('password', 'elementOne');
$form->addElement('password', 'elementTwo', array(
    'validators' => array(
        array('identical', false, array('token' => 'elementOne'))
    )
));

Indem der Elementname vom ersten Element als token für das zweite Element verwendet wird, prüft der Prüfer ob das zweite Element gleich dem ersten Element ist. Im Falle das der Benutzer keine zwei identischen Werte eingegeben hat, erhält man einen Prüffehler.

Wie vorher erwähnt prüft Zend_Validate_Identical die Token strikt. Man kann dieses Verhalten ändern indem die strict Option verwendet wird. Der Standardwert für diese Eigenschaft ist TRUE.

$valid = new Zend_Validate_Identical(array('token' => 123, 'strict' => FALSE));
$input = '123';
if ($valid->isValid($input)) {
    // Die Eingabe scheint gültig zu sein
} else {
    // Die Eingabe ist ungültig
}

Der Unterschied zum vorhergehenden Beispiel besteht darin dass die Prüfung in diesem Fall TRUE zurückgibt, selbst wenn man einen Integerwert mit einem String prüft solange der Inhalt identisch aber nicht vom gleichen Typ ist.

Der Bequemlichkeit halber kann man auch setStrict() und getStrict() verwenden.

Wie alle anderen Prüfungen unterstützt Zend_Validate_Identical auch die Verwendung von Konfigurationseinstellungen als Eingabe Parameter. Das bedeutet das man den Prüfer mit einem Zend_Config Objekt konfigurieren kann.

Aber das führt zu einem weiteren Fall den man berücksichtigen muss. Wenn man ein Array als Vergleichswert verwendet, dann sollte man dieses in einen 'token' Schlüssel einhüllen wenn dieses nur ein Element enthält.

$valid = new Zend_Validate_Identical(array('token' => 123));
if ($valid->isValid($input)) {
    // Der Wert scheint gültig zu sein
} else {
    // Der Wert ist ungültig
}

Das oben stehende Beispiel prüft den Integerwert 123. Der Grund für diesen speziellen Fall ist, dass man den Token der verwendet werden soll, durch Angabe des 'token' Schlüssels, konfigurieren kann.

Wenn der eigene Vergleichswert nur ein Element enthält, und dieses Element 'token' heißt dann muss man dieses, wie im oben stehenden Beispiel gezeigt, einhüllen.

$valid = new Zend_Validate_Identical(array('token' => array('token' => 123)));
if ($valid->isValid($input)) {
    // Der Wert scheint gültig zu sein
} else {
    // Der Wert ist ungültig
}

Die folgenden Optionen werden für Zend_Validate_InArray unterstützt:

Der einfachste Weg ist es, das Array welches durchsucht werden soll, bei der Initiierung anzugeben:

$validator = new Zend_Validate_InArray(array('key' => 'value',
                                             'otherkey' => 'othervalue'));
if ($validator->isValid('value')) {
    // Wert gefunden
} else {
    // Wert nicht gefunden
}

Das verhält sich genauso wie PHP's in_array() Methode.

Natürlich kann man das Array gegen das geprüft werden soll auch im Nachhinein durch Verwendung der setHaystack() Methode angegeben werden. getHaystack() gibt das aktuell gesetzte Haystack Array zurück.

$validator = new Zend_Validate_InArray();
$validator->setHaystack(array('key' => 'value', 'otherkey' => 'othervalue'));

if ($validator->isValid('value')) {
    // Wert gefunden
} else {
    // Wert nicht gefunden
}

Wie vorher erwähnt kann man auch eine Strikte Prüfung im Array durchführen. Standardmäßig würde kein Unterschied zwischen dem Integerwert 0 und dem String "0" sein. Wenn eine strikte Prüfung durchgeführt wird dann wird dieser Unterschied auch geprüft und nur gleiche Typen werden akzeptiert.

Eine strikte Prüfung kann auch auf zwei verschiedenen Wegen durchgeführt werden. Bei der Initiierung und durch Verwendung einer Methode. Bei der Initiierung muß hierfür ein Array mit der folgenden Struktur angegeben werden:

$validator = new Zend_Validate_InArray(
    array(
        'haystack' => array('key' => 'value', 'otherkey' => 'othervalue'),
        'strict'   => true
    )
);

if ($validator->isValid('value')) {
    // Wert gefunden
} else {
    // Wert nicht gefunden
}

Der haystack Schlüssel enthält das eigene Array das für die Prüfung verwendet wird. Durch das Setzen des script Schlüssels auf TRUE wird die Prüfung so durchgeführt, das der Typ strikt geprüft wird.

Natürlich kann man auch die setStrict() Methode verwenden um diese Einstellung im Nachhinein zu ändern und getStrict() um den aktuell gesetzten Status zu erhalten.

Zusätzlich zu PHP's in_array() Methode kann diese Prüfung auch verwendet werden um Mehrdimensionale Arrays zu prüfen.

Um mehrdimensionale Array zu prüfen muß die recursive Option gesetzt werden.

$validator = new Zend_Validate_InArray(
    array(
        'haystack' => array(
            'firstDimension' => array('key' => 'value',
                                      'otherkey' => 'othervalue'),
            'secondDimension' => array('some' => 'real',
                                       'different' => 'key')),
        'recursive' => true
    )
);

if ($validator->isValid('value')) {
    // Wert gefunden
} else {
    // Wert nicht gefunden
}

Das eigene Array wird das rekursiv geprüft um zu sehen ob der angegebene Wert enthalten ist. Zusätzlich kann setRecursive() verwendet werden um diese Option im Nachhinein zu setzen und getRecursive() um Ihn zu erhalten.

$validator = new Zend_Validate_InArray(
    array(
        'firstDimension' => array('key' => 'value',
                                  'otherkey' => 'othervalue'),
        'secondDimension' => array('some' => 'real',
                                   'different' => 'key')
    )
);
$validator->setRecursive(true);

if ($validator->isValid('value')) {
    // Wert gefunden
} else {
    // kein Wert gefunden
}

Die folgenden Optionen werden für Zend_Validate_Int unterstützt:

Der einfachste Weg um einen Integerwert zu prüfen ist die Verwendung der Systemeinstellungen. Wenn keine Optionen angegeben werden, dann wird das Gebietsschema der Umgebung für die Prüfung verwendet:

$validator = new Zend_Validate_Int();

$validator->isValid(1234);   // Gibt true zurück
$validator->isValid(1234.5); // Gibt false zurück
$validator->isValid('1,234'); // Gibt true zurück

Um obigen Beispiel haben wir angenommen das unsere Umgebung auf "en" als Gebietsschema gesetzt ist. Wie man im dritten Beispiel sieht wird auch die Gruppierung erkannt.

Oft ist es nützlich dazu in der Lage zu sein lokalisierte Werte zu prüfen. Integerwerte werden in anderen Ländern oft unterschiedlich geschrieben. Zum Beispiel kann man im Englischen "1234" oder "1,234" schreiben. Beides sind Integerwerte, aber die Gruppierung ist optional. Im Deutschen kann man zum Beispiel "1.234" schreiben und im Französischen "1 234".

Zend_Validate_Int ist in der Lage solche Schreibweisen zu prüfen. Das bedeutet, das es nicht einfach das Trennzeichen entfernt, sondern auch prüft ob das richtige Trennzeichen verwendet wird. Siehe den folgenden Code:

$validator = new Zend_Validate_Int(array('locale' => 'de'));

$validator->isValid(1234); // Gibt true zurück
$validator->isValid("1,234"); // Gibt false zurück
$validator->isValid("1.234"); // Gibt true zurück

Wie man sieht wird die Eingabe, bei Verwendung eines Gebietsschemas, lokalisiert geprüft. Bei Verwendung der englischen Schreibweise erhält man FALSE wenn das Gebietsschema eine andere Schreibweise erzwingt.

Das Gebietsschema kann auch im Nachhinein gesetzt werden indem setLocale() verwendet wird, und empfangen indem man getLocale() verwendet.

Die folgenden Optionen werden für Zend_Validate_Isbn unterstützt:

Ein einfaches Verwendungsbeispiel ist anbei zu finden:

$validator = new Zend_Validate_Isbn();
if ($validator->isValid($isbn)) {
    // ISBN gültig
} else {
    // ISBN ungültig
}

Das prüft jeden ISBN-10 und ISBN-13 Wert ohne Trennzeichen.

Ein Beispiel für die Begrenzung auf einen ISBN Typ ist anbei zu finden:

$validator = new Zend_Validate_Isbn();
$validator->setType(Zend_Validate_Isbn::ISBN13);
// ODER
$validator = new Zend_Validate_Isbn(array(
    'type' => Zend_Validate_Isbn::ISBN13,
));

if ($validator->isValid($isbn)) {
    // Das ist ein gültiger ISBN-13 Wert
} else {
    // Das ist ein ungültiger ISBN-13 Wert
}

Das vorherige prüft nur auf ISBN-13 Werte.

Folgende gültige Typen sind vorhanden:

Ein Beispiel für die Begrenzung auf ein Trennzeichen ist anbei zu finden:

$validator = new Zend_Validate_Isbn();
$validator->setSeparator('-');
// ODER
$validator = new Zend_Validate_Isbn(array(
    'separator' => '-',
));

if ($validator->isValid($isbn)) {
    // Das ist eine gültige ISBN mit Trennzeichen
} else {
    // Das ist eine ungültige ISBN mit Trennzeichen
}

Gültige Separatoren sind:

Die folgenden Optionen werden für Zend_Validate_Ip unterstützt:

Ein einfaches Beispiel für die Verwendung ist anbei:

$validator = new Zend_Validate_Ip();
if ($validator->isValid($ip)) {
    // IP scheint gültig zu sein
} else {
    // IP ist ungültig; Gründe ausgeben
}

Manchmal ist es nützlich nur eines der unterstützten Formate zu prüfen. Zum Beispiel wenn das eigene Netzwert nur IPv4 unterstützt. In diesem Fall wäre es sinnlos IPv6 in der Prüfung zu erlauben.

Um Zend_Validate_Ip auf ein Protokoll zu begrenzen kann man die Optionen allowipv4 oder allowipv6 auf FALSE setzen. Man kann das durchführen indem die Option entweder im Constructor angegeben wird, oder indem setOptions() im Nachhinein verwendet wird.

$validator = new Zend_Validate_Ip(array('allowipv6' => false);
if ($validator->isValid($ip)) {
    // IP scheint eine gültige IPv4 Adresse zu sein
} else {
    // IP ist keine IPv4 Adresse
}

Die folgenden Optionen werden für Zend_Validate_LessThan unterstützt:

Um zu prüfen ob ein angegebener Wert kleiner als eine definierte Grenz ist kann einfach das folgende Beispiel verwendet werden.

$valid  = new Zend_Validate_LessThan(array('max' => 10));
$value  = 10;
$return = $valid->isValid($value);
// Gibt true zurück

Das obige Beispiel gibt für alle Werte TRUE zurück die 10 sind oder kleiner als 10.

Die folgenden Optionen werden für Zend_Validate_NotEmpty unterstützt:

Standardmäßig arbeitet diese Prüfung anders als man es laut PHP's empty() Funktion erwarten würde. Im speziellen evaluiert diese Prüfung den den Integer 0 und den String '0' als leer.

$valid = new Zend_Validate_NotEmpty();
$value  = '';
$result = $valid->isValid($value);
// gibt false zurück

Einige Projekte haben andere Ansichten davon was als "leerer" Wert angesehen wird: ein String der nur Leerzeichen enthält könnte als leer angesehen werden, oder 0 könnte als nicht leer angesehen werden (speziell für boolsche Sequenzen). Um den unterschiedlichen Notwendigkeiten gerecht zu werden erlaubt es Zend_Validate_NotEmpty die Typen zu konfigurieren welche als leer angesehen werden und jene die es nicht werden.

Die folgenden Typen können behandelt werden:

Alle anderen Werte geben standardmäßig TRUE zurück.

Es gibt verschiedene Wege um zu wählen welche der obigen Typen geprüft werden sollen. Man kann ein oder mehrere Typen angeben und Sie hinzufügen, man kann ein Array angeben, man kann Konstanten verwenden, oder man gibt einen textuellen String an. Siehe auch die folgenden Beispiele:

// Gibt bei 0 false zurück
$validator = new Zend_Validate_NotEmpty(Zend_Validate_NotEmpty::INTEGER);

// Gibt bei 0 oder '0' false zurück
$validator = new Zend_Validate_NotEmpty(
    Zend_Validate_NotEmpty::INTEGER + Zend_NotEmpty::ZERO
);

// Gibt bei 0 oder '0' false zurück
$validator = new Zend_Validate_NotEmpty(array(
    Zend_Validate_NotEmpty::INTEGER,
    Zend_Validate_NotEmpty::ZERO
));

// Gibt bei 0 oder '0' false zurück
$validator = new Zend_Validate_NotEmpty(array(
    'integer',
    'zero',
));

Man kann auch eine Instanz von Zend_Config angeben um die gewünschten Typen zu setzen. Um Typen nach der Instanzierung zu setzen kann die Methode setType() verwendet werden.

Grundsätzlich kann man dem Contructor von Zend_Validate_PostCode entweder ein Zend_Locale Objekt, oder einen String der ein voll qualifiziertes Gebietsschema repräsentiert, angeben.

$validator = new Zend_Validate_PostCode('de_AT');
$validator = new Zend_Validate_PostCode($locale);

Zusätzlich kann man dem Contructor entweder ein Array oder ein Zend_Config Objekt übergeben. Wenn man das tut, muss man entweder den Schlüssel "locale" oder "format" verwenden; diese werden verwendet um die betreffenden Werte im Prüfobjekt zu setzen.

$validator = new Zend_Validate_PostCode(array(
    'locale' => 'de_AT',
    'format' => 'AT_\d+'
));

Die folgenden Optionen werden für Zend_Validate_PostCode unterstützt:

Die folgenden Optionen werden für Zend_Validate_Regex unterstützt:

Die Prüfung mit Regular Expressions erlaubt es komplizierte Prüfungen durchzuführen, ohne das eine eigene Prüfung geschrieben werden muss. Die Verwendung von Regular Expressions ist relativ üblich und einfach. Sehen wir uns ein Beispiel an:

$validator = new Zend_Validate_Regex(array('pattern' => '/^Test/');

$validator->isValid("Test"); // Gibt true zurück
$validator->isValid("Testing"); // Gibt true zurück
$validator->isValid("Pest"); // Gibt false zurück

Wie man sehen kann hat das Pattern welches anzugeben ist die gleiche Syntax wie für preg_match(). Für Details über Regular Expressions sollte man einen Blick in PHP's Handbuch über die PCRE Pattern Syntax werfen.

Es ist auch möglich andere Pattern im Nachhinein zu setzen indem setPattern() verwendet wird, und das aktuell gesetzte Pattern mit getPattern() erhalten.

$validator = new Zend_Validate_Regex(array('pattern' => '/^Test/');
$validator->setPattern('ing$/');

$validator->isValid("Test"); // Gibt false zurück
$validator->isValid("Testing"); // Gibt true zurück
$validator->isValid("Pest"); // Gibt false zurück

Prüft ob ein String gültig ist um Ihn als 'changefreq' Element in einem Sitemap XML Dokument zu verwenden. Gültige Elemente sind: 'always', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', oder 'never'.

Gibt TRUE zurück wenn und nur wenn der Wert ein String ist und mit einer der oben spezifizierten Frequenzen übereinstimmt.

Prüft ob ein String gültig ist um Ihn als 'lastmod' Element in einem Sitemap XML Dokument zu verwenden. Das lastmod Element sollte einen W3C Datumsstring enthalten, und optional Informationen über die Zeit enthalten.

Gibt TRUE zurück wenn, und nur wenn, der angegebene Wert ein String und in Bezug auf das Prokoll gültig ist.

$validator = new Zend_Validate_Sitemap_Lastmod();

$validator->isValid('1999-11-11T22:23:52-02:00'); // true
$validator->isValid('2008-05-12T00:42:52+02:00'); // true
$validator->isValid('1999-11-11'); // true
$validator->isValid('2008-05-12'); // true

$validator->isValid('1999-11-11t22:23:52-02:00'); // false
$validator->isValid('2008-05-12T00:42:60+02:00'); // false
$validator->isValid('1999-13-11'); // false
$validator->isValid('2008-05-32'); // false
$validator->isValid('yesterday'); // false

Prüft ob ein String für die Verwendung als 'loc' Element in einem Sitemap XML Dokument gültig ist. Er verwendet intern Zend_Form::check(). Mehr darüber kann man unter URI Prüfung lesen.

Prüft ob ein Wert für die Verwendung als 'priority' Element in einem Sitemap XML Dokument gültig ist. Der Wert sollte ein Dezimalwert zwischen 0.0 und 1.0 sein. Diese Prüfung akzeptiert sowohl nummerische Werte als auch Stringwerte.

$validator = new Zend_Validate_Sitemap_Priority();

$validator->isValid('0.1'); // true
$validator->isValid('0.789'); // true
$validator->isValid(0.8); // true
$validator->isValid(1.0); // true

$validator->isValid('1.1'); // false
$validator->isValid('-0.4'); // false
$validator->isValid(1.00001); // false
$validator->isValid(0xFF); // false
$validator->isValid('foo'); // false

Es gibt keine unterstützten Optionen für irgendeine der Sitemap Prüfungen.

Die folgenden Optionen werden von Zend_Validate_StringLength unterstützt:

Standardmäßig prüft diese Prüfung ob ein Wert zwischen min und max ist. Aber für min ist der Standardwert 0 und für max ist er NULL, was unlimitiert bedeutet.

Deshalb prüft diese Prüfung standardmäßig, ohne das eine Option angegeben wurde, nur ob die Eingabe ein String ist.

Um die maximal erlaubte Länge eines Strings zu begrenzen muss man die Eigenschaft max setzen. Sie akzeptiert einen Integerwert als Eingabe.

$validator = new Zend_Validate_StringLength(array('max' => 6));

$validator->isValid("Test"); // Gibt true zurück
$validator->isValid("Testing"); // Gibt false zurück

Man kann die maximal erlaubte Länge auch im Nachhinein setzen indem die setMax() Methode verwendet wird. Und getMax() um die aktuelle maximale Grenze zu erhalten.

$validator = new Zend_Validate_StringLength();
$validator->setMax(6);

$validator->isValid("Test"); // Gibt true zurück
$validator->isValid("Testing"); // Gibt false zurück

Um die mindestens benötigte Länge eines Strings zu begrenzen muss man die Eigenschaft min setzen. Sie akzeptiert einen Integerwert als Eingabe.

$validator = new Zend_Validate_StringLength(array('min' => 5));

$validator->isValid("Test"); // Gibt false zurück
$validator->isValid("Testing"); // Gibt true zurück

Man kann die mindestens benötigte Länge auch im Nachhinein setzen indem die setMin() Methode verwendet wird. Und getMin() um die aktuelle Mindestgrenze zu erhalten.

$validator = new Zend_Validate_StringLength();
$validator->setMin(5);

$validator->isValid("Test"); // Gibt false zurück
$validator->isValid("Testing"); // Gibt true zurück

Manchmal ist es notwendig einen String zu erhalten der eine maximal definierte Länge, aber auch eine Mindestlänge hat. Wenn man, zum Beispiel, eine Textbox hat in welcher der Benutzer seinen Namen angeben kann, könnte man den Namen auf maximal 30 Zeichen begrenzen. Aber man will auch sicher gehen das er seinen Namen angegeben hat. Deshalb setzt man die zumindest benötigte Länge auf 3 Zeichen. Siehe das folgende Beispiel:

$validator = new Zend_Validate_StringLength(array('min' => 3, 'max' => 30));

$validator->isValid("."); // Gibt false zurück
$validator->isValid("Test"); // Gibt true zurück
$validator->isValid("Testing"); // Gibt true zurück

Strings verwenden immer eine Kodierung. Selbst wenn man keine explizite Kodierung verwendet, dann verwendet PHP eine. Wenn die eigene Anwendung eine andere Kodierung verwendet als PHP selbst, dann sollte man eine Kodierung setzen.

Man kann eine eigene Kodierung bei der Instanzierung mit der encoding Option setzen, oder indem die setEncoding() Methode verwendet wird. Wir nehmen an das die eigene Installation ISO verwendet und die Anwendung auf ISO gesetzt ist. In diesem Fall sieht man das folgende Verhalten.

$validator = new Zend_Validate_StringLength(
    array('min' => 6)
);
$validator->isValid("Ärger"); // Gibt false zurück

$validator->setEncoding("UTF-8");
$validator->isValid("Ärger"); // Gibt true zurück

$validator2 = new Zend_Validate_StringLength(
    array('min' => 6, 'encoding' => 'UTF-8')
);
$validator2->isValid("Ärger"); // Gibt true zurück

Wenn die eigene Installation und die Anwendung also unterschiedliche Kodierungen verwenden, dann sollte man immer selbst eine Kodierung setzen.