Previous Next

Standard Prüfklassen

Zend Framework kommt mit einem Standardset von Prüfklassen, welche fertig zur Verwendung sind.

Alnum

Zend_Validate_Alnum erlaubt es zu prüfen ob ein angegebener Wert nur alphabetische Zeichen und Ziffern enthält. Es gibt keine Begrenzung der Länge für die Eingabe welche geprüft werden soll.

Unterstützte Optionen für Zend_Validate_Alnum

Die folgenden Optionen werden von Zend_Validate_Alnum unterstützt:

  • allowWhiteSpace: Ob Leerzeichen erlaubt sind. Diese Option ist standardmäßig FALSE

Standardverhalten

Das folgende ist ein Standardbeispiel:

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

Verwendung von Leerzeichen

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ärend 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
}

Andere Sprachen verwenden

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.

Alpha

Zend_Validate_Alpha erlaubt es zu prüfen ob ein angegebener Wert nur alphabetische Zeichen enthält. Es gibt keine Begrenzung der Länge für die Eingabe welche man prüfen will. Diese Prüfung ist ähnlich wie die Zend_Validate_Alnum Prüfung mit der Ausnahme dass Sie keine Ziffern akzeptiert.

Unterstützte Optionen für Zend_Validate_Alpha

Die folgenden Optionen werden von Zend_Validate_Alpha unterstützt:

  • allowWhiteSpace: Ob Leerzeichen erlaubt sind. Diese Option ist standardmäßig FALSE

Standardverhalten

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
}

Verwendung von Leerzeichen

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ärend 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
}

Andere Sprachen verwenden

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.

Barcode

Zend_Validate_Barcode erlaubt es zu prüfen ob ein gegebener Wert als Barcode repräsentiert werden kann.

Zend_Validate_Barcode unterstützt viele Barcode Standards und kann sehr einfach mit prorietären Barcode Implementationen erweitert werden. Die folgenden Barcode Standards werden unterstützt:

  • CODE25: Oft auch "Two of Five" oder "Code 25 Industrial" genannt.

    Dieser Barcode hat keine Begrenzung der Länge. Es unterstützt nur Ziffern, und die letzte Ziffer kann eine optionale Checksumme sein welche durch Modulo 10 berechnet wird. Dieser Standard sehr alt und wird heutzutage nicht oft verwendet. Übliche Anwendungsfälle liegen in der Industrie.

  • CODE25INTERLEAVED: Oft auch "Code 2 of 5 Interleaved" genannt.

    Dieser Standard ist eine Variante von CODE25. Er hat keine Begrenzung der Länge, muss aber eine gerade Anzahl an Zeichen enthalten. Es unterstützt nur Ziffern, und die letzte Ziffer kann eine optionale Checksumme sein welche durch Modulo 10 berechnet wird. Dieser Standard wird weltweit verwendet und üblicherweise im Handel.

  • CODE39: CODE39 ist einer der ältesten vorhandenen Codes.

    Dieser Barcode hat eine variable Länge. Er unterstützt Ziffern, großgeschriebene alphabetische Zeichen und 7 spezielle Zeichen wie Leerzeichen, Punkte und Dollarzeichen. Er kann eine optionale Checksumme enthalten welche durch Modulo 43 berechnet wird. Dieser Standard wird weltweit verwendet und üblicherweise in der Industrie.

  • CODE39EXT: CODE39EXT ist eine Erweiterung von CODE39.

    Dieser Barcode hat die gleichen Eigenschaften wie CODE39. Zusätzlich erlaubt er die Verwendung aller 128 ASCII Zeichen. Dieser Standard wird weltweit verwendet und ist in der Industrie üblich.

  • CODE93: CODE93 ist der Nachfolger von CODE39.

    Dieser Barcode hat eine variable Länge. Er unterstützt Ziffern, alphabetische Zeichen und 7 spezielle Zeichen. Er enthält eine optionale Checksumme welche durch Modulo 47 berechnet wird und aus 2 Zeichen besteht. Dieser Standard produziert einen kompakteren Code als CODE39 und ist sicherer.

  • CODE93EXT: CODE93EXT ist eine Erweiterung von CODE93.

    Dieser Barcode hat die gleichen Eigenschaften wie CODE93. Zusätzlich erlaubt er die Verwendung aller 128 ASCII Zeichen. Dieser Standard wird weltweit verwendung und ist in der Industrie üblich.

  • EAN2: EAN ist die Abkürzung für "European Article Number".

    Dieser Barcode muss 2 Zeichen haben. Er unterstützt nur Ziffern und hat keine Checksumme. Dieser Standard wird hauptsächlich als Zusatz zu EAN13 (ISBN) verwendet wenn diese auf Bücher gedruckt werden.

  • EAN5: EAN ist die Abkürzung für "European Article Number".

    Dieser Barcode muss 5 Zeichen haben. Er unterstützt nur Ziffern und hat keine Checksumme. Dieser Standard wird hauptsächlich als Zusatz zu EAN13 (ISBN) verwendet wenn diese auf Bücher gedruckt werden.

  • EAN8: EAN ist die Abkürzung für "European Article Number".

    Dieser Barcode kann eine Länge von 7 oder 8 Zeichen haben. Er unterstützt nur Ziffern. Wenn er 8 Zeichen lang ist enthält er eine Checksumme. Dieser Standard wird weltweit verwendet, hat aber eine sehr begrenzte Reichweite. Er kann auf kleinen Artikeln gefunden werden wo ein längerer Barcode nicht gedruckt werden könnte.

  • EAN12: EAN ist die Abkürzung für "European Article Number".

    Dieser Barcode muss eine Länge von 12 Zeichen haben. Er unterstützt nur Ziffern wobei die letzte Ziffer immer eine Checksumme ist welche durch Modulo 10 berechnet wird. Dieser Standard wird in der USA verwendet und hierbei üblicherweise im Handel. Er wurde ersetzt durch EAN13.

  • EAN13: EAN ist die Abkürzung für "European Article Number".

    Dieser Barcode muss eine Länge von 13 Zeichen haben. Er unterstützt nur Ziffern wobei die letzte Ziffer immer eine Checksumme ist welche durch Modulo 10 berechnet wird. Dieser Standard wird weltweit verwendet, üblicherweise im Handel.

  • EAN14: EAN ist die Abkürzung für "European Article Number".

    Dieser Barcode muss eine Länge von 14 Zeichen haben. Er unterstützt nur Ziffern wobei die letzte Ziffer immer eine Checksumme ist welche durch Modulo 10 berechnet wird. Dieser Standard wird weltweit verwendet, üblicherweise im Handel. Er ist der Nachfolger von EAN13.

  • EAN18: EAN ist die Abkürzung für "European Article Number".

    Dieser Barcode muss eine Länge von 18 Zeichen haben. Er unterstützt nur Ziffern. Die letzte Ziffer ist immer eine Checksumme welche durch Modulo 10 berechnet wird. Dieser Code wird ost für die Identifizierung von Transport Containern verwendet.

  • GTIN12: GTIN ist die Abkürzung für "Global Trade Item Number".

    Dieser Barcode verwendet den gleichen Standard wie EAN12 und ist sein Nachfolger. Er wird üblicherweise in den USA verwendet.

  • GTIN13: GTIN ist die Abkürzung für "Global Trade Item Number".

    Dieser Barcode verwendet den gleichen Standard wie EAN13 und ist sein Nachfolger. Er wird weltweit von der Industrie verwendet.

  • GTIN14: GTIN ist die Abkürzung für "Global Trade Item Number".

    Dieser Barcode verwendet den gleichen Standard wie EAN14 und ist sein Nachfolger. Er wird weltweit verwendet, üblicherweise im Handel.

  • IDENTCODE: Identcode wird von Deutsche Post und DHL verwendet. Es ist eine spezialisierte Implementation von Code25.

    Dieser Barcode muss eine Länge von 12 Zeichen haben. Er unterstützt nur Ziffern und die letzte Ziffer ist immer eine Checksumme die mit Modulo 10 berechnet wird. Dieser Standard wird hauptsächlich von den Firmen DP und DHL verwendet.

  • INTELLIGENTMAIL: Intelligent Mail ist ein postalischer Barcode.

    Dieser Barcode kann eine Länge von 20, 25, 29 oder 31 Zeichen haben. Er unterstützt nur Ziffern und enthält keine Checksumme. Dieser Standard ist der Nachfolger von PLANET und POSTNET. Er wird hauptsächlich von den United States Post Services verwendet.

  • ISSN: ISSN ist die Abkürzung für International Standard Serial Number.

    Dieser Barcode kann eine Länge von 8 oder 13 Zeichen haben. Er unterstützt nur Ziffern wobei die letzte Ziffer eine Checksumme ist welche durch Modulo 11 berechnet wird. Er wird weltweit für gedruckte Publikationen verwendet.

  • ITF14: ITF14 ist die GS1 Implementation des Interleaved Two of Five Barcodes.

    Dieser Barcode ist eine spezielle Variante von Interleaved 2 of 5. Er muss eine Länge von 14 Zeichen haben und basiert auf GTIN14. Er unterstützt nur Ziffern wobei die letzte Ziffer die Ziffer einer Checksumme ist welche durch Modulo 10 berechnet wird. Er wird weltweit verwendet, üblicherweise im Handel.

  • LEITCODE: Leitcode wird von Deutsche Post und DHL verwendet. Er ist eine spezialisierte Implementation von Code25.

    Dieser Barcode muss eine Länge von 14 Zeichen haben. Er unterstützt nur Ziffern, wobei die letzte Ziffer immer eine Checksumme ist welche durch Modulo 10 berechnet wird. Dieser Standard wird hauptsächlich von den Firmen DP und DHL verwendet.

  • PLANET: Planet ist die Abkürzung für Postal Alpha Numeric Encoding Technique.

    Dieser Barcode kann eine Länge von 12 oder 14 Zeichen haben. Er unterstützt nur Ziffern wobei die letzt Ziffer immer eine Checksumme ist. Dieser Standard wird hauptsächlich von den United States Post Services verwendet.

  • POSTNET: Postnet wird vom US Post Service verwendet.

    Dieser Barcode kann eine Länge von 6, 7, 10 oder 12 Zeichen haben. Er unterstützt nur Ziffern wobei die letzte Ziffer immer eine Checksumme ist. Dieser Standard wird hauptsächlich von den United States Post Services verwendet.

  • ROYALMAIL: Royalmail wird von Royal Mail verwendet.

    Dieser Barcode hat keine definierte Länge. Er unterstützt Ziffern, großgeschriebene Buchstaben und die letzte Ziffer ist immer eine Checksumme. Dieser Standard wird hauptsächlich von Royal Mail für deren Cleanmail Service verwendet. Er wird auch RM4SCC genannt.

  • SSCC: SSCC ist die Abkürzung für "Serial Shipping Container Code".

    Dieser Barcode ist eine Variante des EAN Barcodes. Er muss eine Länge von 18 Zeichen enthalten und unterstützt nur Ziffern. Die letzte Ziffer muss ein Ziffer für eine Checksumme sein welche durch Modulo 10 berechnet wird. Er wird üblicherweise in der Transport Industrie verwendet.

  • UPCA: UPC ist die Abkürzung für "Univeral Product Code".

    Dieser Barcode ist der Vorgänger von EAN13. Er muss eine Länge von 12 Zeichen haben und unterstützt nur Ziffern. Die letzte Ziffer muss die Ziffer einer Checksumme sein welche durch Modulo 10 berechnet wird. Er wird üblicherweise in den USA verwendet.

  • UPCE: UPCE ist die kurze Variante von UPCA.

    Dieser Barcode ist die kleinere Variante von UPCA. Er muss eine Länge von 6, 7 oder 8 Zeichen haben und unterstützt nur Ziffern. Wenn der Barcode 8 Ziffern lang ist enthält er eine Checksumme die durch Modulo 10 berechnet wird. Er wird üblicherweise bei kleinen Produkten verwendet wo ein UPCA Barcode nicht passen würde.

Unterstützte Optionen für Zend_Validate_Barcode

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

  • adapter: Setzt den Barcode Adapter welcher verwendet wird. Unterstützt werden alle vorher genannten Adapter. Wenn ein selbst definierter Adapter verwendet werden soll, muss man den kompletten Klassennamen setzen.

  • checksum: TRUE wenn der Barcode eine Prüfsumme enthalten soll. Der Standardwert hängt vom verwendeten Adapter ab. Es ist zu beachten das einige Adapter es nicht erlauben diese Option zu setzen.

  • options: Definiert optionale Optionen für selbst geschriebene Adapter.

Grundsätzliche Verwendung

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
}

Optionale Checksumme

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
}

Hinweis: Reduzierte Sicherheit durch ausgeschaltete Prüfung der Checksumme

Indem die Prüfung der Checksumme ausgeschaltet wird, verringert man auch die Sicherheit der verwendeten Barcodes. Zusätzlich sollte man beachten dass man die Prüfung der Checksumme für jene Barcode Typen ausschalten kann welche einen Wert für die Checksumme enthalten müssen. Barcodes welche nicht gültig wären könnten dann als gültig zurückgegeben werden, selbst wenn Sie es nicht sind.

Schreiben eigener Adapter

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.

  • Length: Die Länge welche der Barcode haben muss. Diese kann einen der folgenden Werte haben:

    • Integer: Ein Wert größer als 0, was bedeutet das der Barcode diese Länge haben muss.

    • -1: Es gibt keine Begrenzung der Länge für diesen Barcode.

    • "even": Die Länge dieses Barcodes muss eine gerade Anzahl an Ziffern enthalten.

    • "odd": Die Länge dieses Barcodes muss eine ungerade Anzahl an Ziffern enthalten.

    • array: Ein Array von Integer Werten. Die Länge dieses Barcodes muss einer der gesetzten Array Werte haben.

  • Characters: Ein String der die erlaubten Zeichen für diesen Barcode enthält. Auhc der Integer Wert 128 ist erlaubt, was für die ersten 128 Zeichen der ASCII Tabelle steht.

  • Checksum: Ein Strung der als Callback für eine Methode verwendet wird, welche die Prüfung der Checksumme durchführt.

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
}

Between

Zend_Validate_Between erlaubt es zu prüfen ob ein angegebener Wert zwischen zwei anderen Werten ist.

Hinweis: Zend_Validate_Between unterstützt nur die Prüfung von Nummern

Es ist zu beachten das Zend_Validate_Between nur die Prüfung von Nummern unterstützt. Strings, oder ein Datum können mit dieser Prüfung nicht geprüft werden.

Unterstützte Optionen für Zend_Validate_Between

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

  • inclusive: Definiert ob die Prüfung inklusive oder explusive der minimalen und maximalen Grenzwerte ist. Sie ist standardmäßig TRUE.

  • max: Setzt die maximale Grenze für die Prüfung.

  • min: Setzt die minimale Grenze für die Prüfung.

Standardverhalten für Zend_Validate_Between

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.

Prüfung exklusive den Grenzwerten

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.

Callback

Zend_Validate_Callback erlaubt es einen Callback anzugeben der verwendet wird um einen angegebenen Wert zu prüfen.

Unterstützte Optionen für Zend_Validate_Callback

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

  • callback: Setzt den Callback welcher für die Prüfung aufgerufen wird.

  • options: Setzt zusätzliche Optionen welche an den Callback übergeben werden.

Grundsätzliche Verwendung

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
}

Verwendung mit Closures

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
}

Verwendung mit klassenbasierten Callbacks

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
}

Optionen hinzufügen

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.

CreditCard

Zend_Validate_CreditCard erlaubt es zu prüfen ob ein angegebener Wert eine Kreditkarten Nummer sein könnte.

Eine Kreditkarte enthält verschiedene Elemente an Metadaten, inklusive ein Hologramm, die Accountnummer, Logo, Ablaufdatum, Sicherheitscode und den Namen des Kreditkartenbesitzers. Die Algorithmen für die Prüfung der Kombination an Metadaten sind nur der ausgebenden Firma bekannt, und sollten mit Ihnen zum Zwecke der Zahlung geprüft werden. Trotzdem ist es oft nützlich zu wissen ob eine akutell angegebene Nummer in den Bereich der möglichen Nummern fällt bevor so eine Überprüfung durchgeführt wird, und daher prüft Zend_Validate_CreditCard einfach ob die angegebene Kreditkartennummer entspricht.

Für die Fälle in denen man ein Service hat, das tiefere Prüfungen durchführt, bietet Zend_Validate_CreditCard auch die Möglichkeit einen Service Callback anzuhängen der ausgeführt wird sobald die Kreditkartennummer vorbehaltlich als gültig geprüft wurde; dieser Callback wird dann ausgeführt, und sein Rückgabewert wird die komplette Gültigkeit erkennen.

Die folgenden Kreditkarteninstitute werden akzeptiert:

  • American Express

    China UnionPay

    Diners Club Card Blanche

    Diners Club International

    Diners Club US & Canada

    Discover Card

    JCB

    Laser

    Maestro

    MasterCard

    Solo

    Visa

    Visa Electron

Hinweis: Ungültige Institute

Die Institute Bankcard und Diners Club enRoute existieren nicht mehr. Deshalb werden Sie als ungültig erkannt.

Switch wurde zu Visa umbenannt und wird daher auch als ungültig erkannt.

Unterstützte Optionen für Zend_Validate_CreditCard

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

  • service: Ein Callback zu einem Online Service welcher zusätzlich für die Prüfung verwendet wird.

  • type: Der Typ der Kreditkarte der geprüft werden soll. Siehe die folgende Liste an Instituten für Details.

Grundsätzliche Verwendung

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.

Definierte Kreditkarte akzeptieren

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)
));
Konstanten für Kreditkarten Institute
Institut Konstante
American Express AMERICAN_EXPRESS
China UnionPay UNIONPAY
Diners Club Card Blanche DINERS_CLUB
Diners Club International DINERS_CLUB
Diners Club US & Canada DINERS_CLUB_US
Discover Card DISCOVER
JCB JCB
Laser LASER
Maestro MAESTRO
MasterCard MASTERCARD
Solo SOLO
Visa VISA
Visa Electron VISA

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

Hinweis: Standard Institute

Wenn bei der Initiierung kein Institut angegeben wird, dann wird ALL verwendet, welches alle Institute auf einmal verwendet.

In diesem Fall ist die Verwendung von addType() sinnlos weil bereits alle Institute hinzugefügt wurden.

Prüfung durch Verwendung einer fremden API

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.

Ccnum

Hinweis:

Die Ccnum Prüfung sollte nicht mehr eingesetzt werden. Stattdessen sollte man die CreditCard Prüfung verwenden. Aus Gründen der Sicherheit sollte man CreditCard statt Ccnum verwenden.

Date

Zend_Validate_Date erlaubt es zu prüfen ob ein angegebener Wert ein Datum enthält. Diese Prüfung prüft auch lokalisierte Eingaben.

Unterstützte Optionen für Zend_Validate_Date

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

  • format: Setzt das Format welches verwendet wird um das Datum zu schreiben.

  • locale: Setzt das Gebietsschema welches verwendet wird um Datumswerte zu prüfen.

Standardmäßige Datumsprüfung

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'.

Lokalisierte Datumsprüfung

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.

Selbst definierte Datumsprüfung

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

Db_RecordExists und Db_NoRecordExists

Zend_Validate_Db_RecordExists und Zend_Validate_Db_NoRecordExists bieten die Möglichkeit zu testen ob ein Eintrag in einer angegebenen Tabelle einer Datenbank, mit einem gegebenen Wert, existiert.

Unterstützte Optionen für Zend_Validate_Db_*

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

  • adapter: Der Datenbank-Adapter welcher für die Suche verwendet wird.

  • exclude: Setzt die Einträge welche von der Suche ausgenommen werden.

  • field: Das Datenbank-Feld in dieser Tabelle welches nach dem Eintrag durchsucht wird.

  • schema: Setzt das Schema welches für die Suche verwendet wird.

  • table: Die Tabelle welche nach dem Eintrag durchsucht wird.

Grundsätzliche Verwendung

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.

Ausnehmen von Einträgen

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.

Datenbank Adapter

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

Datenbank Schemas

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'
    )
);

Digits

Zend_Validate_Digit prüft ob ein angegebener Wert nur Ziffern enthält.

Unterstützte Optionen für Zend_Validate_Digits

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

Prüfen von Ziffern

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

Hinweis: Nummern prüfen

Wenn man Nummern oder nummerische Werte prüfen will, muss man darauf achten dass diese Prüfung nur auf Ziffern prüft. Das bedeutet dass jedes andere Zeichen wie ein Trennzeichen für Tausender oder ein Komma diese Prüfung nicht bestehen. In diesem Fall sollte man Zend_Validate_Int oder Zend_Validate_Float verwenden.

Email Adresse

Zend_Validate_EmailAddress erlaubt die Prüfung von Email Adressen. Der Prüfer teilt zuerst die Email Adresse in lokalen Teil @ hostname und versucht diese mit bekannten Spezifikationen für Email Adressen und Hostnamen zu prüfen.

Normale Verwendung

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 $validator->getMessages() eine nützliche Fehlermeldung aus.

Optionen für die Prüfung von Email Adressen

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:

  • allow: Definiert welche Typen von Domain Namen akzeptiert werden. Diese Option wird in Verbindung mit der hostname Option verwendet um die Hostname Prüfung zu setzen. Für weitere Informationen über mögliche Werte dieser Option sehen Sie bitte unter Hostname und mögliche ALLOW* Konstanten. Der Standardwert dieser Option ist ALLOW_DNS.

  • deep: Definiert ob die MX Records des Server durch eine tiefe Prüfung verifiziert werden sollen. Wenn diese Option auf TRUE gesetzt wird, dann werden zusätzlich zum MX Record auch die A, A6 und AAAA Records verwendet um zu prüfen ob der Server Emails akzeptiert. Der Standardwert dieser Option ist FALSE.

  • domain: Definiert ob der Domain Teil geprüft werden soll. Wenn diese Option auf FALSE gesetzt wird, dann wird nur der lokale Teil der Email Adresse geprüft. In diesem Fall wird die Hostname Prüfung nicht aufgerufen. Der Standardwert dieser Option ist TRUE.

  • hostname: Setzt die Hostname Prüfung mit welcher der Domain Teil der Email Adresse geprüft wird.

  • mx: Definiert ob der MX Record vom Server erkannt werden soll. Wenn diese Option auf TRUE definiert wird, dann wird der MX Record verwendet um zu prüfen ob der Server Emails akzeptiert. Der Standardwert dieser Option ist FALSE.

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

Komplexe lokale Abschnitte

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).

Nur den lokalen Teil prüfen

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

Prüfen von unterschiedlichen Typen von Hostnamen

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

Prüfen ob der Hostname aktuell Emails akzeptiert

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

Hinweis: Die MX Prüfung unter Windows

In Windows Umgebungen ist die MX Prüfung nicht vorhanden wenn PHP 5.3 oder höher verwendet wird. Unter PHP 5.3 wird die MX Prüfung nicht verwendet, selbst wenn diese in den Optionen aktiviert wurde.

Alternativ kann entweder TRUE oder FALSE an $validator->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
    )
);
Warnung

Performance Warnung

Man sollte darauf achten das die Aktivierung der MX Prüfung das Skript langsamer machen wird, weil es Netzwerk Funktionen verwendet. Die Aktivierung der tiefen Prüfung macht das Skript sogar noch langsamer da es im angegebenen Server nach 3 zusätzlichen Typen sucht.

Hinweis: Disallowed IP addresses

Man sollte beachten das die MX Prüfung nur für externe Server akzeptiert wird. Wenn die tiefe MX Prüfung aktiviert wird, dann werden IP Adressen wie 192.168.* oder 169.254.* nicht akzeptiert.

Internationale Domain Namen prüfen

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.

Top Level Domains 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.

Setzen von Meldungen

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.

Float

Zend_Validate_Float erlaubt es zu prüfen ob ein angegebener Wert eine Gleitkommazahl enthält. Diese Prüfung kann auch lokalisierte Eingaben prüfen.

Unterstützte Optionen für Zend_Validate_Float

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

  • locale: Setzt das Gebietsschema welches verwendet wird um lokalisierte Gleitkommazahlen zu prüfen.

Einfache Float Prüfung

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.

Lokalisierte Prüfung von Gleitkommazahlen

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.

GreaterThan

Zend_Validate_GreaterThan erlaubt es zu prüfen ob ein angegebener Wert größer ist als ein minimaler Grenzwert.

Hinweis: Zend_Validate_GreaterThan unterstützt nur die Überprüfung von Nummern

Es sollte beachtet werden das Zend_Validate_GreaterThan nur die Prüfung von Nummern unterstützt. Strings oder ein Datum können mit dieser Prüfung nicht geprüft werden.

Unterstützte Optionen für Zend_Validate_GreaterThan

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

  • min: Setzt den mindesten erlaubten Wert.

Normale Verwendung

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  = 10;
$return = $valid->isValid($value);
// Gibt true zurück

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

Hex

Zend_Validate_Hex erlaubt es zu prüfen ob ein angegebener Wert nur hexadezimale Zeichen enthält. Das sint alle Zeichen von 0 bis 9 und unabhängig von der Schreibweise A bis F. Es gibt keine Begrenzung der Länge für den Wert welchen man prüfen will.

$validator = new Zend_Validate_Hex();
if ($validator->isValid('123ABC')) {
    // Der Wert enthält nur Hex Zeichen
} else {
    // Falsch
}

Hinweis: Ungültige Zeichen

Alle anderen Zeichen geben false zurück, inklusive Leerzeichen und Kommazeichen. Auch Unicode Nullzeichen und Ziffern von anderen Schriften als Latein werden nicht als gültig erkannt.

Unterstützte Optionen für Zend_Validate_Hex

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

Hostname

Zend_Validate_Hostname erlaubt die Prüfung von Hostnamen mit einem Set von bekannten Spezifikationen. Es ist möglich drei verschiedene Typen von Hostnamen zu Prüfen: einen DNS Hostnamen (z.b. domain.com), IP Adressen (z.B. 1.2.3.4), und lokale Hostnamen (z.B. localhost). Standarmäßig werden nur DNS Hostnamen geprüft.

Unterstützte Optionen für Zend_Validate_Hostname

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

  • allow: Definiert die Art des Hostnamens welche verwendet werden darf. Siehe Hostname Typen für Details.

  • idn: Definiert ob IDN Domains erlaubt sind oder nicht. Diese Option ist standardmäßig TRUE.

  • ip: Erlaubt es eine eigene IP Prüfung zu definieren. Diese Option ist standardmäßig eine neue Instanz von Zend_Validate_Ip.

  • tld: Definiert ob TLDs geprüft werden. Diese Option ist standardmäßig TRUE.

Normale Verwendung

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.

Verschiedene Typen von Hostnamen prüfen

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

Internationale Domain Namen prüfen

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.

Hinweis: IDN Domains

Bis jetzt unterstützen mehr als 50 ccTLDs IDN Domains.

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.

Hinweis: IDN Prüfung

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

Top Level Domains prüfen

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.

Hinweis: TLD Prüfung

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

Iban

Zend_Validate_Iban prüft ob ein angegebener Wert eine IBAN Nummer sein könnte. IBAN ist die Abkürzung für "International Bank Account Number".

Unterstützte Optionen für Zend_Validate_Iban

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

  • locale: Setzt das Gebietsschema welches verwendet wird um das IBAN Format für die Prüfung zu erhalten.

IBAN Prüfung

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.

Anwendungsweites Gebietsschema

Wir können das Anwendungsweite Gebietsschema verwenden. Dass bedeutet, wenn keine Option bei der Instanzierung angegeben wird, das Zend_Validate_Iban nach dem Anwendungsweiten Gebietsschema sucht. Siehe den folgenden Codeabschnitt:

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

Hinweis: Anwendungsweites Gebietsschema

Natürlich funktioniert dies nur wenn das Anwendungsweite Gebietsschema in der Registry vorher gesetzt wurde. Andernfalls wird Zend_Locale versuchen das Gebietsschema zu verwenden welches der Client sendet, oder wenn keines gesendet wurde, das Gebietsschema der Umgebung. Man sollte darauf achten das dies zu ungewünschtem Verhalten bei der Prüfung führen kann.

Unscharfe IBAN Prüfung

Manchmal ist es nützlich, nur zu prüfen ob der angegebene Wert eine IBAN Nummer ist oder nicht. Das bedeutet das man nicht auf ein definiertes Land prüfen will. Das kann getan werden indem ein FALSE als Gebietsschema verwendet wird.

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

So wird jede IBAN Nummer gültig sein. Es ist zu beachten dass man dies nicht tun sollte wenn man nur Konten von einem einzelnen Land akzeptiert.

Gebietsschema verwendende IBAN Prüfung

Um gegen ein definiertes Land zu prüfen muss man nur das gewünschte Gebietsschema angeben. Man kann dies mit der locale Option tun, und bei Verwendung von setLocale() auch im Nachhinein.

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

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

Hinweis: Vollständig qualifizierte Gebietsschemas verwenden

Man muss ein vollständig qualifiziertes Gebietsschema verwenden. Andernfalls kann das Land nicht korrekt erkannt werden, da gleiche Sprachen in mehreren Ländern gesprochen werden.

Identical

Zend_Validate_Identical erlaubt es zu prüfen ob ein angegebener Wert mit einem angegebenen Vergleichswert identisch ist.

Unterstützte Optionen für Zend_Validate_Identical

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

  • strict: Definiert ob die Prüfung strikt durchgeführt werden soll. Der Standardwert ist TRUE.

  • token: Setzt den Token gegen den die Eingabe geprüft werden soll.

Grundsätzliche Verwendung

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.

Identische Objekte

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
}

Hinweis: Vergleich des Typs

Man sollte darauf acht geben das der Typ einer Variable für die Prüfung verwendet wird. Das bedeutet das der String '3' nicht identisch ist mit dem Integerwert 3. Wenn man eine nicht strikte Prüfung durchführen will muss man die strict Option setzen.

Formular Elemente

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.

Strikte Prüfung

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.

Konfiguration

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
}

InArray

Zend_Validate_InArray erlaubt es zu prüfen ob ein gegebener Wert in einem Array enthalten ist. Er ist auch in der Lage mehrdimensionale Arrays zu prüfen.

Unterstützte Optionen für Zend_Validate_InArray

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

  • haystack: Setzt den Haystack für die Prüfung.

  • recursive: Definiert ob die Prüfung rekursiv durchgeführt werden soll. Diese Option ist standardmäßig FALSE.

  • strict: Definiert ob die Prüfung strikt durchgeführt werden soll. Diese Option ist standardmäßig FALSE.

Einfache Array Prüfung

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.

Hinweis:

Standardmäßig ist diese Prüfung nicht strikt noch kann Sie mehrdimensionale Arrays prüfen.

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
}

Strikte Array Prüfung

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.

Hinweis:

Es ist zu beachten das die strict Einstellung standardmäßig FALSE ist.

Rekursive Array Prüfung

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
}

Hinweis: Standardwert für die Rekursion

Standardmäßig ist die rekursive Prüfung ausgeschaltet.

Hinweis: Optionsschlüssel im Haystack

Wenn man die Schlüssel 'haystack', 'strict' oder 'recursive' im eigenen Haystack verwenden, dann muß man diese mit dem haystack Schlüssel einhüllen.

Int

Zend_Validate_Int prüft ob ein angegebener Wert ein Integer (Ganzzahl) ist. Auch lokalisierte Integerwerte werden erkannt und können geprüft werden.

Unterstützte Optionen für Zend_Validate_Int

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

  • locale: Setzt das Gebietsschema welches verwendet wird um lokalisierte Integerwerte zu prüfen.

Einfache Integer Prüfung

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.

Lokalisierte Integer Prüfung

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.

Isbn

Zend_Validate_Isbn erlaubt es einen ISBN-10 oder ISBN-13 Wert zu prüfen.

Unterstützte Optionen für Zend_Validate_Isbn

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

  • separator: Definiert das erlaubte Trennzeichen für die ISBN Nummer. Diese ist standardmäßig ein leerer String.

  • type: Definiert den erlaubten Typ an ISBN Nummern. Dieser ist standardmäßig Zend_Validate_Isbn::AUTO. Für Details sollte in diesem Abschnitt nachgesehen werden.

Einfache Verwendung

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.

Einen expliziten ISBN Prüfungstyp setzen

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:

  • Zend_Validate_Isbn::AUTO (default)

  • Zend_Validate_Isbn::ISBN10

  • Zend_Validate_Isbn::ISBN13

Eine Begrenzung auf ein Trennzeichen spezifizieren

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
}

Hinweis: Werte ohne Trennzeichen

Es ist zu beachten das dies FALSE zurückgibt wenn $isbn kein Trennzeichen oder einen ungültigen ISBN Wert enthält.

Gültige Separatoren sind:

  • "" (Leer) (Standardwert)

  • "-" (Bindestrich)

  • " " (Leerzeichen)

Ip

Zend_Validate_Ip erlaubt es zu Prüfen ob ein gegebener Wert eine IP Adresse ist. Er unterstützt den IPv4 und auch den IPv6 Standard.

Unterstützte Optionen für Zend_Validate_Ip

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

  • allowipv4: Definiert ob die Prüfung IPv4 Adressen erlaubt. Diese Option ist standardmäßig TRUE.

  • allowipv6: Definiert ob die Prüfung IPv6 Adressen erlaubt. Diese Option ist standardmäßig TRUE.

Grundsätzliche Verwendung

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
}

Hinweis: Ungültige IP Adressen

Es ist zu beachten das Zend_Validate_Ip nur IP Adressen prüft. Adressen wie 'mydomain.com' oder '192.168.50.1/index.html' sind keine gültigen IP Adressen. Sie sind entweder Hostnamen oder gültige URLs, aber keine IP Adressen.

Hinweis: IPv6 Prüfung

Zend_Validate_Ip prüft IPv6 Adressen mit einer Regex. Der Grund ist, dass die Filter und Methoden von PHP der RFC nicht folgen. Viele andere vorhandene Klassen folgen Ihr auch nicht.

IPv4 oder IPv6 alleine prüfen

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
}

Hinweis: Standard Verhalten

Das Standardverhalten dem Zend_Validate_Ip folgt, ist es beide Standards zu erlauben.

LessThan

Zend_Validate_LessThan erlaubt es zu prüfen ob ein angegebener Wert kleiner als ein maximaler Grenzwert ist. Das ist der Cousine von Zend_Validate_GreaterThan.

Hinweis: Zend_Validate_LessThan unterstützt nur die Prüfung von Nummern

Es sollte beachtet werden das Zend_Validate_LessThan nur die Prüfung von Nummern unterstützt. Strings oder ein Datum können mit dieser Prüfung nicht geprüft werden.

Unterstützte Optionen für Zend_Validate_LessThan

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

  • max: Setzt den maximal erlaubten Wert.

Normale Verwendung

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.

NotEmpty

Dieser Prüfer erlaubt es zu prüfen ob ein angegebener Wert nicht leer ist. Das ist oft nützlich wenn man mit Formular Elementen oder anderen Benutzereingaben arbeitet, und man sicherstellen will das den benötigten Elementen Werte zugeordnet wurden.

Unterstützte Optionen für Zend_Validate_NotEmpty

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

  • type: Setzt den Typ der Prüfung welcher durchgeführt wird. Für Details sollte in diesem Abschnitt nachgesehen werden.

Standardverhalten für Zend_Validate_NotEmpty

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

Hinweis: Unterschiedliches Standardverhalten zu PHP

Ohne Angabe einer Konfiguration ist das Verhalten von Zend_Validate_NotEmpty anders als das von PHP.

Ändern des Verhaltens für Zend_Validate_NotEmpty

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:

  • boolean: Gibt FALSE zurück wenn der boolsche Wert FALSE ist.

  • integer: Gibt FALSE zurück wenn ein Integerwert 0 angegeben ist. Standardmäßig ist diese Prüfung nicht aktiviert und gibt bei jedem Integerwert TRUE zurück.

  • float: Gibt FALSE zurück wenn die Gleitkommazahl 0.0 angegeben ist. Standardmäßig ist diese Prüfung nicht aktiviert und gibt bei jeder Gleitkommazahl TRUE zurück.

  • string: Gibt FALSE zurück wenn ein leerer String '' angegeben wird.

  • zero: Gibt FALSE zurück wenn das einzelne Zeichen Null ('0') angegeben wird.

  • empty_array: Gibt FALSE zurück wenn ein leeres array angegeben wird.

  • null: Gibt FALSE zurück wenn ein NULL Wert angegeben wird.

  • php: Gibt bei den gleichen Gründen FALSE zurück wo auch PHP's Methode empty() TRUE zurückgeben würde.

  • space: Gibt FALSE zurück wenn ein String angegeben wird der nur Leerzeichen enthält.

  • object: Gibt TRUE zurück wenn ein Objekt angegeben wurde. FALSE wird zurückgegeben wenn object nicht erlaubt, aber ein Objekt angegeben wurde.

  • object_string: Gibt FALSE zurück wenn ein Objekt angegeben wurde und dessen __toString() Methode einen leeren String zurückgibt.

  • object_count: Gibt FALSE zurück wenn ein Objekt angegeben wurde, es ein Countable Interface hat und seine Anzahl 0 ist.

  • all: Gibt bei allen oben stehenden Typen FALSE zurück.

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.

PostCode

Zend_Validate_PostCode erlaubt es zu eruieren ob ein angegebener Wert eine gültige Postleitzahl ist. Postleitzahlen sind spezifisch für Städte und in einigen Gebietsschemata auch als ZIP Codes bezeichnet.

Zend_Validate_PostCode kennt mehr als 160 unterschiedliche Formate für Postleitzahlen. Um das richtige Format auszuwählen gibt es 2 Wege. Man kann entweder ein voll qualifiziertes Gebietsschema verwenden, oder ein eigenes Format manuall setzen.

Die Verwendung eines Gebietsschemas ist bequemer da Zend Framework bereits die entsprechenden Formate für Postleitzahlen für jedes Gebietsschema kennt; aber muss man ein voll qualifiziertes Gebietsschema verwenden (eines das eine Region spezifiziert) damit es funktioniert. Das Gebietsschema "de" zum Beispiel ist zwar ein Gebietsschema, kann aber nicht mit Zend_Validate_PostCode verwendet werden da es keine Region enthält; "de_AT" andererseits würde ein gültiges Gebietsschema sein da es den Region Code spezifiziert ("AT", für Österreich).

$validator = new Zend_Validate_PostCode('de_AT');

Wenn man das Gebietsschema nicht selbst setzt, dann verwendet Zend_Validate_PostCode das anwendungsweit gesetzte Gebietsschema, oder wenn keines vorhanden ist, das Gebietsschema welches von Zend_Locale zurückgegeben wird.

// Anwendungsweites Gebietsschema in der Bootstrap
$locale = new Zend_Locale('de_AT');
Zend_Registry::set('Zend_Locale', $locale);

$validator = new Zend_Validate_PostCode();

Man kann das Gebietsschema auch im Nachhinein ändern, indem man setLocale() aufruft. Und natürlich kann man das aktuelle Gebietsschema erhalten indem getLocale() aufgerufen wird.

$validator = new Zend_Validate_PostCode('de_AT');
$validator->setLocale('en_GB');

Postleitzahlen Formate selbst sind einfache Regular Expression Strings. Wenn das internationale Postleitzahlen Format, welches durch das Setzen des Gebietsschemas verwendet wird, den eigenen Bedüfnissen nicht entspricht, dann kann man ein Format auch manuell setzen indem setFormat() aufgerufen wird.

$validator = new Zend_Validate_PostCode('de_AT');
$validator->setFormat('AT-\d{5}');

Hinweis: Konventionen für selbst definierte Formate

Wenn selbst definierte Formate verwendet werden sollten die Start- ('/^') und Endetags ('$/') nicht angegeben werden. Sie werden automatisch hinzugefügt.

Man sollte darauf achtgeben das Postleitzahlen Werte immer auf einer strikte Art geprüft werden. Das bedeutet das Sie alleinstehend geschrieben werden müssen, ohne zusätzliche Zeichen, wenn diese nicht durch das Format abgedeckt werden.

Optionen des Constructors

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+'
));

Unterstützte Optionen für Zend_Validate_PostCode

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

  • format: Setzt das Postleitzahl-Format welches für die Prüfung der Eingabe verwendet werden soll.

  • locale: Setzt ein Gebietsschema von dem die Postleitzahl genommen wird.

Regex

Diese Prüfung erlaubt es zu prüfen ob ein angegebener String einer definierten Regular Expression entspricht.

Unterstützte Optionen für Zend_Validate_Regex

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

  • pattern: Setzt das Pattern der Regular Expression für diese Prüfung.

Prüfen mit Zend_Validate_Regex

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.

Handhabung von Pattern

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

Sitemap Prüfungen

Die folgenden Prüfungen entsprechen dem » Sitemap XML Protokoll.

Sitemap_Changefreq

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.

Sitemap_Lastmod

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.

Beispiel #1 Sitemap Lastmod Prüfung

$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

Sitemap_Loc

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.

Sitemap_Priority

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.

Beispiel #2 Sitemap Priority Prüfung

$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

Unterstützte Optionen für Zend_Validate_Sitemap_*

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

StringLength

Diese Prüfung erlaubt es zu prüfen ob ein angegebener String eine definierte Länge besitzt.

Hinweis: Zend_Validate_StringLength unterstützt nur die Prüfung von Strings

Es ist zu beachten das Zend_Validate_StringLength nur die Prüfung von Strings unterstützt. Integer, Floats, Datumswerte oder Objekte können mit dieser Prüfung nicht überprüft werden.

Unterstützte Optionen für Zend_Validate_StringLength

Die folgenden Optionen werden von Zend_Validate_StringLength unterstützt:

  • encoding: Setzt die Kodierung von ICONV welche für den String verwendet wird.

  • min: Setzt die erlaubte Mindestlänge für einen String.

  • max: Setzt die erlaubte Maximallänge für einen String.

Standardverhalten für Zend_Validate_StringLength

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.

Die maximal erlaubte Länge eines String begrenzen

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

Die mindestens benötigte Länge eines Strings begrenzen

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

Einen String auf beiden Seiten begrenzen

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

Hinweis: Eine kleinere Maximalgrenze als die Mindestgrenze setzen

Wenn man versucht eine kleinere Maximalgrenze zu setzen als der aktuelle Mindestwert, oder eine größere Mindestgrenze als den aktuellen Maximalwert, dann wird eine Exception geworfen.

Kodierung von Werten

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.

Previous Next
Einführung zum Zend Framework
Übersicht
Installation
Einstieg ins Zend Framework
Schnellstart in den Zend Framework
Zend Framework & MVC Einführung
Das Projekt erstellen
Ein Layout erstellen
Ein Modell und eine Datenbank Tabelle erstellen
Erstellen eines Formulars
Gratulation!
Autoloading im Zend Framework
Einführung
Ziele und Design
Grundsätzliche Verwendung von Autoloadern
Automatisches Laden von Ressourcen
Zusammenfassung
Plugins im Zend Framework
Einführung
Verwenden von Plugins
Fazit
Einstieg in Zend_Layout
Einführung
Zend_Layout verwenden
Zend_Layout: Fazit
Einstieg in Zend_View Platzhalter
Einführung
Grundsätzliche Verwendung von Platzhaltern
Standard Platzhalter
View Platzhalter: Fazit
Zend_Form's Gestalter (Decorator) verstehen und verwenden
Einführung
Decorator Grundlagen
Layeraufbau von Decorators
Darstellung individueller Decorators
Erstellung und Darstellung von kombinierten Elementen
Fazit
Einstieg in Zend_Session, Zend_Auth, und Zend_Acl
Erstellung von Multi-User Anwendungen mit Zend Framework
User Session im Zend Framework managen
Benutzer im Zend Framework authentifizieren
Erstellung eines Authorisations Systems in Zend Framework
Einstieg in Zend_Search_Lucene
Einführung in Zend_Search_Lucene
Lucene Index Struktur
Indezes öffnen und erstellen
Indizierung
Suchen
Unterstützte Abfragen
Seitendarstellung von Suchergebnissen
Einstieg in Zend_Paginator
Einführung
Einfaches Beispiel
Seitenkontrolle und ScrollingStyles
Alles zusammenfügen
Zend Framework's Referenz
Zend_Acl
Einführung
Verfeinern der Zugriffskontrolle
Fortgeschrittene Verwendung
Zend_Amf
Einführung
Zend_Amf_Server
Zend_Application
Einführung
Zend_Application Quick Start
Theorie der Funktionsweise
Beispiele
Kern Funktionalität
Vorhandene Ressource Plugins
Zend_Auth
Einführung
Datenbanktabellen Authentifizierung
Digest Authentication
HTTP Authentication Adapter
LDAP Authentifizierung
Open ID Authentifikation
Zend_Barcode
Einführung
Barcodes mit Hilfe der Zend_Barcode Klasse erstellen
Zend_Barcode Objekte
Zend_Barcode Renderer
Zend_Cache
Einführung
Die Theorie des Cachens
Zend_Cache Frontends
Zend_Cache Backends
Der Cache Manager
Zend_Captcha
Einführung
Captcha Anwendung
CAPTCHA Adapter
Zend_CodeGenerator
Einführung
Zend_CodeGenerator Beispiele
Zend_CodeGenerator Referenz
Zend_Config
Einleitung
Theory of Operation
Zend_Config_Ini
Zend_Config_Xml
Zend_Config_Writer
Zend_Config_Writer
Zend_Console_Getopt
Einführung
Definieren von Getopt Regeln
Holen von Optionen und Argumenten
Konfigurieren von Zend_Console_Getopt
Zend_Controller
Zend_Controller Schnellstart
Zend_Controller Grundlagen
Der Front Controller
Das Request Objekt
Der Standard Router
Der Dispatcher
Action Controller
Action Helfer
Das Response Objekt
Plugins
Eine konventionelle modulare Verzeichnis Struktur verwenden
MVC Ausnahmen
Zend_Currency
Einführung in Zend_Currency
Zend_Currency verwenden
Optionen für Währungen
Was macht eine Währung aus?
Wo ist die Währung?
Wie sieht die Währung aus?
Wie viel Währung habe ich?
Rechnen mit Währungen
Währungen wechseln
Zusätzliche Informationen für Zend_Currency
Zend_Date
Einführung
Theorie der Arbeitsweise
Basis Methoden
Zend_Date API Übersicht
Erstellen von Datumswerten
Konstanten für generelle Datums Funktionen
Funktionierende Beispiele
Zend_Db
Zend_Db_Adapter
Zend_Db_Statement
Zend_Db_Profiler
Zend_Db_Select
Zend_Db_Table
Zend_Db_Table_Row
Zend_Db_Table_Rowset
Zend_Db_Table Relationships
Zend_Db_Table_Definition
Zend_Debug
Variablen ausgeben
Zend_Dojo
Einführung
Zend_Dojo_Data: dojo.data Envelopes
Dojo View Helfer
Formular Elemente und Dekoratore für Dojo
Support für den Build Layer von Zend_Dojo
Zend_Dom
Einführung
Zend_Dom_Query
Zend_Exception
Verwenden von Ausnahmen
Grundsätzliche Verwendung
Vorherige Exceptions
Zend_Feed
Einführung
Feeds importieren
Feeds von Websites abrufen
Einen RSS Feed konsumieren
Einen Atom Feed konsumieren
Einen einzelnen Atom Eintrag konsumieren
Verändern der Feed- und Eintragsstruktur
Eigene Klassen für Feeds und Einträge
Zend_Feed_Reader
Zend_Feed_Writer
Zend_Feed_Pubsubhubbub
Zend_File
Zend_File_Transfer
Prüfungen für Zend_File_Transfer
Filter für Zend_File_Transfer
Zend_Filter
Einführung
Standard Filter Klassen
Filter Ketten
Filter schreiben
Zend_Filter_Input
Zend_Filter_Inflector
Zend_Form
Zend_Form
Schnellstart mit Zend_Form
Erstellen von Form Elementen mit Hilfe von Zend_Form_Element
Erstellen von Form durch Verwendung von Zend_Form
Erstellen von eigenem Form Markup durch Zend_Form_Decorator
Standard Form Elemente die mit dem Zend Framework ausgeliefert werden
Standard Formular Dekoratoren die mit dem Zend Framework ausgeliefert werden
Internationalisierung von Zend_Form
Fortgeschrittene Verwendung von Zend_Form
Zend_Gdata
Einführung
Authentifizierung mit AuthSub
Die Buchsuche Daten API verwenden
Authentifizieren mit ClientLogin
Google Kalender verwenden
Verwenden der Google Dokumente Listen Daten API
Verwenden von Google Health
Google Tabellenkalkulation verwenden
Google Apps Provisionierung verwenden
Google Base verwenden
Picasa Web Alben verwenden
Verwenden der YouTube Daten API
Gdata Ausnahmen auffangen
Zend_Http
Einführung
Zend_Http_Client - Fortgeschrittende Nutzung
Zend_Http_Client - Verbindungsadapter
Zend_Http_Cookie und Zend_Http_CookieJar
Zend_Http_Response
Zend_InfoCard
Einführung
Zend_Json
Einführung
Grundlegende Verwendung
Fortgeschrittene Verwendung von Zend_Json
XML zu JSON Konvertierung
Zend_Json_Server - JSON-RPC Server
Zend_Layout
Einführung
Zend_Layout Schnellstart
Zend_Layout Konfigurations Optionen
Erweiterte Verwendung von Zend_Layout
Zend_Ldap
Einführung
API Übersicht
Szenarien der Verwendung
Tools
Objektorientierter Zugriff auf den LDAP Baum durch Verwendung von Zend_Ldap_Node
Informationen vom LDAP Server erhalten
Serialisieren von LDAP Daten von und zu LDIF
Zend_Loader
Dynamisches Laden von Dateien und Klassen
Der Autoloader
Ressource Autoloader
Plugins laden
Zend_Locale
Einführung
Zend_Locale verwenden
Normalisierung und Lokalisierung
Arbeiten mit Daten und Zeiten
Unterstützte Gebietsschemata
Zend_Log
Übersicht
Writer
Formatter
Filter
Die Factory verwenden um ein Log zu erstellen
Zend_Mail
Einführung
Versand über SMTP
Versand von mehreren E-Mails über eine SMTP Verbindung
Verwendung von unterschiedlichen Versandwegen
HTML E-Mail
Anhänge
Empfänger hinzufügen
Die MIME Abgrenzung kontrollieren
Zusätzliche Kopfzeilen
Zeichensätze
Kodierung
SMTP Authentifizierung
SMTP Übertragungen sichern
Lesen von Mail Nachrichten
Zend_Markup
Einführung
Beginnen mit Zend_Markup
Zend_Markup Parser
Zend_Markup Renderer
Zend_Measure
Einführung
Erstellung einer Maßeinheit
Ausgabe von Maßeinheiten
Manipulation von Maßeinheiten
Arten von Maßeinheiten
Zend_Memory
Übersicht
Memory Manager
Memory Objekte
Zend_Mime
Zend_Mime
Zend_Mime_Message
Zend_Mime_Part
Zend_Navigation
Einführung
Seiten
Container
Zend_Oauth
Einführung zu OAuth
Zend_OpenId
Einführung
Zend_OpenId_Consumer Grundlagen
Zend_OpenId_Provider
Zend_Paginator
Einführung
Verwendung
Konfiguration
Advanced usage
Zend_Pdf
Einführung
Erstellen und Laden von PDF Dokumenten
Änderungen an PDF Dokumenten speichern
Arbeiten mit Seiten
Zeichnen
Interaktive Features
Dokument Informationen und Metadaten
Anwendungsbeispiel für die Zend_Pdf Komponente
Zend_ProgressBar
Zend_ProgressBar
Zend_Queue
Einführung
Beispiel der Verwendung
Framework
Adapter
Anpassen von Zend_Queue
Stomp
Zend_Reflection
Einführung
Zend_Reflection Beispiele
Zend_Reflection Referenz
Zend_Registry
Die Registry verwenden
Zend_Rest
Einführung
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Überblick
Indexerstellung
Einen Index durchsuchen
Abfragesprache
Abfrage Erzeugungs API
Zeichensätze
Erweiterbarkeit
Zusammenarbeit Mit Java Lucene
Erweitert
Die besten Anwendungen
Zend_Serializer
Einführung
Zend_Serializer_Adapter
Zend_Server
Einführung
Zend_Server_Reflection
Zend_Service
Einführung
Zend_Service_Akismet
Zend_Service_Amazon
Zend_Service_Amazon_Ec2
Zend_Service_Amazon_Ec2: Instanzen
Zend_Service_Amazon_Ec2: Windows Instanzen
Zend_Service_Amazon_Ec2: Reservierte Instanzen
Zend_Service_Amazon_Ec2: CloudWatch Monitoring
Zend_Service_Amazon_Ec2: Amazon Maschinen Images (AMI)
Zend_Service_Amazon_Ec2: Elastischer Block Speicher (EBS)
Zend_Service_Amazon_Ec2: Elastische IP Adressen
Zend_Service_Amazon_Ec2: Schlüsselpaare
Zend_Service_Amazon_Ec2: Regionen und Availability Zones
Zend_Service_Amazon_Ec2: Sicherheitsgruppen
Zend_Service_Amazon_S3
Zend_Service_Amazon_Sqs
Zend_Service_Audioscrobbler
Zend_Service_Delicious
Zend_Service_DeveloperGarden
Zend_Service_Flickr
Zend_Service_LiveDocx
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_Simpy
Zend_Service_SlideShare
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Mitgelieferte Services
Zend_Service_StrikeIron: Erweiterte Verwendung
Zend_Service_Technorati
Zend_Service_Twitter
Zend_Service_WindowsAzure
Zend_Service_Yahoo
Zend_Session
Einführung
Grundsätzliche Verwendung
Fortgeschrittene Benutzung
Globales Session Management
Zend_Session_SaveHandler_DbTable
Zend_Soap
Zend_Soap_Server
Zend_Soap_Client
WSDL Zugriffsmethoden
AutoDiscovery
Zend_Tag
Einführung
Zend_Tag_Cloud
Zend_Test
Einführung
Zend_Test_PHPUnit
Zend_Test_PHPUnit_Db
Zend_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Einführung
Arbeiten mit Zend_TimeSync
Zend_Tool
Verwendung von Zend_Tool auf der Kommandozeile
Zend_Tool erweitern
Zend_Tool_Framework
Einführung
Verwenden des CLI Tools
Architektur
Erstellen von Providern für die Verwendung mit Zend_Tool_Framework
Mitgelieferte System Provider
Extending and Configuring Zend_Tool_Framework
Zend_Tool_Project
Einführung
Ein Projekt erstellen
Project Provider für Zend_Tool
Zend_Tool_Project Internas
Zend_Translate
Einführung
Adapter für Zend_Translate
Verwendung der Übersetzungsadapter
Erstellen von Quelldateien
Zusätzliche Features für Übersetzungen
Schreibweisen von Pluralformen für Übersetzungen
Zend_Uri
Zend_Uri
Zend_Validate
Einführung
Standard Prüfklassen
Kettenprüfungen
Schreiben von Prüfern
Prüfungsmeldungen
Zend_Version
Die Version des Zend Frameworks erhalten
Zend_View
Einführung
Controller Skripte
View Scripte
View Helfer
Zend_View_Abstract
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Einführung
Zend_XmlRpc_Client
Zend_XmlRpc_Server
ZendX_Console_Process_Unix
ZendX_Console_Process_Unix
ZendX_JQuery
Introduction
ZendX_JQuery View Helpers
ZendX_JQuery Form Elements and Decorators
Zend Framework Voraussetzungen
Einführung
Zend Framework's Migrationshinweise
Zend Framework 1.10
Zend Framework 1.9
Zend Framework 1.8
Zend Framework 1.7
Zend Framework 1.6
Zend Framework 1.5
Zend Framework 1.0
Zend Framework 0.9
Zend Framework 0.8
Zend Framework 0.6
Zend Framework Coding Standard für PHP
Übersicht
PHP Dateiformatierung
Namens Konventionen
Code Stil
Zend Framework Dokumentations Standard
Übersicht
Formatierung von Dokumentationsdateien
Empfehlungen
Vorgeschlagene Struktur für die Projekt Struktur von Zend Framework MVC Anwendungen
Übersicht
Vorgeschlagene Verzeichnis Struktur für Projekte
Modul Struktur
Leitfaden für die Rewrite Konfiguration
Zend Framework's Performanceratgeber
Einführung
Laden von Klassen
Zend_Db Performance
Internationalisierung (I18n) und Lokalisierung (L10n)
Darstellen der View
Urheberrecht Informationen