Formular Validierung

#Avedo · 27.12.2008, 23:33

Hallo!
Ich habe seit längerem das Problem, dass ich des öfteren Daten aus Formularen überprüfen muss. Dies möchte ich aber möglichst ohne tausende if()-Abfragen und mit einer ausreichenden Fehlermeldung machen. Also habe ich mir überlegt eine Klasse zu schreiben, die diese Aufgabe für mich übernimmt. Leider bin ich mit dem Ergebnis nicht wirklich zufrieden, weiß aber leider auch nicht, wie ich es besser machen soll. Deshalb würde ich mich über Anregungen und Tips freuen.
MfG, Andy

PHP-Code:

  <?
error_reporting(E_ALL);

/***
* Class Validator 
*
* Validator class allows checking 
* variables for the right content rather
* the type. If a given variable is not 
* of the right type the class will store
* an error message into the private class
* variable.
*  
* @package Validator
* @version 0.1
* @author Andreas Wilhelm <xxxxxxxxxxx@xxxxxx>
* @copyright Andreas Wilhelm
**/  
class Validator 
{
    // private class variables
    private $errors = array();

    /**
    * clear() - Clears the errors array
    *
    * @access public
    * @return NONE
    */
    public function clear()
    {
        $errors = array();
    }

    /**
    * isNum() - Checks if the given parameter is numeric
    *
    * @access public
    * @param Mix $param
    * @param Str $name
    * @return NONE
    */
    public function isNum($param, $name)
    {
        if( !is_numeric($param) )
        {
            $this->setError("Invaild {$name}.");
        }
    }

    /**
    * isInt() - Checks if the given parameter is an integer
    *
    * @access public
    * @param Mix $param
    * @param Str $name
    * @return NONE
    */
    public function isInt($param, $name)
    {
        if( !is_int($param) )
        {
            $this->setError("Invaild {$name}.");
        }
    }

    /**
    * isFloat() - Checks if the given parameter is a float
    *
    * @access public
    * @param Mix $param
    * @param Str $name
    * @return NONE
    */
    public function isFloat($param, $name)
    {
        if( !is_float($param) )
        {
            $this->setError("Invaild {$name}.");
        }
    }

    /**
    * isString() - Checks if the given parameter is a string
    *
    * @access public
    * @param Mix $param
    * @param Str $name
    * @return NONE
    */
    public function isString($param, $name)
    {
        if( !is_string($param) )
        {
            $this->setError("Invaild {$name}.");
        }
    }

    /**
    * isBool() - Checks if the given parameter is a boolean
    *
    * @access public
    * @param Mix $param
    * @param Str $name
    * @return NONE
    */
    public function isBool($param, $name)
    {
        if( !is_bool($param) )
        {
            $this->setError("Invaild {$name}.");
        }
    }

    /**
    * isArray() - Checks if the given parameter is an array
    *
    * @access public
    * @param Mix $param
    * @param Str $name
    * @return NONE
    */
    public function isArray($param, $name)
    {
        if( !is_array($param) )
        {
            $this->setError("Invaild {$name}.");
        }
    }

    /**
    * isObject() - Checks if the given parameter is an object
    *
    * @access public
    * @param Mix $param
    * @param Str $name
    * @return NONE
    */
    public function isObject($param, $name)
    {
        if( !is_object($param) )
        {
            $this->setError("Invaild {$name}.");
        }
    }
    
    /***
    * isMail() - Checks for valid email addresses
    *
    * @access public
    * @param Mix $param
    * @return NONE
    */
    public function isMail($param)
    {
        // set pattern for mail address
        $pattern = '/^([a-zA-Z0-9])+([\.a-zA-Z0-9_-])*@([a-zA-Z0-9_-])+(\.[a-zA-Z0-9_-]+)+/';
        
        // check for mail address
        if( preg_match($pattern, $param) )
        {
            $this->setError("Invaild email-address.");
        }
    }
    
    /***
    * isMail() - Checks for valid uri
    *
    * @access public
    * @param Mix $param
    * @param Str $name
    * @return NONE
    */
    public function isUri($param, $name)
    {
        // set pattern for uri
        $pattern = "(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&amp;:/~\+#]*[\w\-\@?^=%&amp;/~\+#])?";
        
        // check for mail address
        if( preg_match($pattern, $param) )
        {
            $this->setError("Invaild {$name}.");
        }
    }    
    
    /***
    * isPlz() - Checks for valid postcode
    *
    * @access public
    * @param Mix $param
    * @return NONE
    */
    public function isPlz($param)
    {
        // set pattern for uri
        $pattern = "^(s-|S-){0,1}[0-9]{3}\s?[0-9]{2}$";
        
        // check for mail address
        if( preg_match($pattern, $param) )
        {
            $this->setError("Invaild postcode.");
        }
    }

    /**
    * equals() - Checks if one entry equals the other
    *
    * @access public
    * @param Mix $param_1
    * @param Mix $param_2
    * @param Str $name
    * @return NONE
    */
    public function equals($param_1, $param_2, $name)
    {
        if( $param_1 !== $param_2 )
        {
                $this->setError("{$name} must be correct two times.");
        }
    }

    /**
    * length() - Checks the length of a parameter
    *
    * @access public
    * @param Mix $param
    * @param Str $name
    * @param Int $max
    * @param Int $min
    * @return NONE
    */
    public function length($param, $name, $max, $min = 0)
    {
        if( !(strlen($param) < $min) )
        {
            $this -> setError("To long {$name}.");
        }
        
        if( !(strlen($param) > $max))
        {
            $this -> setError("To short {$name}.");
        }
    }

    /**
    * isValid() - Checks if there are any errors
    *
    * @access public
    * @return Boolean
    */
    public function isValid()
    {
        if( empty($this->errors) )
        {
                return true;
        }
        
        return false;
    }

    /**
    * setError() - Adds an error message to the array
    *
    * @access private
    * @param Str $msg
    * @return NONE
    */
    private function setError($msg)
    {
        $this->errors[] = $msg;
    }

    /**
    * __toString() - Returns the errors
    *
    * @access public
    * @return String
    */
    public function __toString()
    {
        // instance variable that holds return
        $return = '';
    
        foreach( $this->errors as $error)
        {
            $return .= $error . "<br />";
        }
    
        return $return;
    }
}
?>

Manko10 · 28.12.2008, 01:15

Hmm, dazu fällt mir jetzt auch gerade nichts Gescheites ein.
Also wenn du keinen Overhead scheust, könntest du pro Formularelement ein Objekt anlegen und die Validierungen als Visitors dranklemmen, aber ob das wirklich das Gelbe vom Ei ist…

Was ich dir allerdings empfehlen würde, ist die Formulare auf jeden Fall als Objekte aufzufassen. Der Validator kann dann über diese Objekte iterieren und die Werte validieren.
Bei deinem Ansatz ist es bisher so, dass der Validator aus einer Ansammlung von Methoden zur Datenvalidierung besteht, die aber alle von außen angestoßen und mit Werten gefüttert werden müssen. Meiner Meinung nach ist die Validierung aber Aufgabe des Validators und deshalb sollte der Validator selbst auch die Validierung koordinieren.

Just my 2 Cents, awaiting Doc's response.

P.S. in deinem eigenen Interesse habe ich mal die E-Mail-Adresse aus dem Code entfernt.

robo47 · 28.12.2008, 01:40

Also was Form Generierung + Validierung angeht fand ich Zend_Form sehr angenehm das nutzt noch Zend_Validate und Zend_Filter und damit lässt sich sehr schnell und einfach ein formular mit validierung, automatischem platzieren der fehlermeldungen im formular etc realisieren.

Ich denke das haupt problem bei deinem beispiel ist, du hast eine Klasse, wenn du ne neue art der validierung willst, musst du die klasse erweitern. Bastel dir ein Interface das z.b. eine methode valid($value) [z.b. weitere noch für getErrors() oder so) und bau darauf alle deine "validatoren" auf.
und dann erstellst du eine klasse auf dem interface dem man validatoren mit ner methode übergeben kann, so kannst du mehrere validatoren hinter einen klemmen und schon brauchst du nur noch eine klasse übergeben und machst im hintergrund multiple validierungen.

z.b. finde ich isInt auch ... problematisch, ein wert der aus einem formular via post oder get kommt wird NIE ein int sein, auch wenn er nur aus zahlen besteht ist es ein string. numeric währe hier passender.

#Avedo · 28.12.2008, 03:34

Das Zend-Framework kommt leider diesmal nicht mehr in Frage. Musss leider auch gestehen, dass ich nicht so ganz verstehe, was ihr mir da vorschlagt. Kann mir jemand ein kleines Beispiel zeigen?
mfG, Andy

dr.e. · 28.12.2008, 11:19

Zitat:

Zitat von Manko10

Just my 2 Cents, awaiting Doc's response.

Meine Sicht der Dinge ist nicht so unterschiedlich wie du denkst. Mit den Form-TagLibs des APF komme ich der Kapselung eines Formulars komplett nach, definierte Tag-Attributen eines Formular-Elements ermöglichen Validierung und (seit neuestem) Filterung von Eingabe-Werten. Durch die Definition der Validatoren und Filter in den Tags behält man die Flexibilität der Formulargestaltung und ist nicht auf Dekoratoren angewiesen. Hier die relevanten Stellen in der Dokumentation:

* Formulare :: Adventure PHP Framework (APF)
* Formulare :: Adventure PHP Framework (APF)

Einziges Manko bisher ist, dass die Validatoren noch nicht so "hübsch" konfiguriert werden können wie die Filter (Stichwort: Erweiterung), bisher war der Satz an Validatoren jedoch ausreichend.

@Andy:
Folgende Anmerkungen habe ich zu deiner Klasse:

- Wie kommt diese zur Anwendung in einem Formular-Element?
- isPlz() sollte besser isZipCode() heißen?
- isObject() wird bei Formularen wohl nicht benötigt werden, da keine (PHP-)Objekte übertragen werden können?
- Wie bildest du Verkettung von Validatoren? Bei deiner Klasse müssten das n Aufrufe von Methoden gefolgt von isValid() sein, richtig?

robo47 · 28.12.2008, 12:12

Hier mal ein Beispielcode den ich grad getippt, nicht sonderlich ordentlich, lässt sich noch stark erweitern, nur um das Schema mal zu zeigen was ich meinte, so in "etwa" läuft das ganze auch beim Zend Framework ab nur dass dort noch etwas mehr Funktionalität vorhanden ist.

PHP-Code:

  <?php
error_reporting(E_ALL | E_STRICT);

Interface My_Validator_Interface
{
/**
 *
 * @param mixed $value
 * @return boolean
 */
    public function isValid($value);

    /**
     * Returns all errors
     * @return array
     */
    public function getErrors();
}

Class My_MinLength_Validator implements My_Validator_Interface
{
    protected $_minLenght = 3;

    protected $_errors = array();

    public function __construct($minLenght = 3) {
        $this->_minLenght = $minLenght;
    }

    public function isValid($value) {
        if (strlen($value) < $this->_minLenght) {
            $this->_errors[] = sprintf('Input "%s" is too short, should be at least %s signs long',$value, $this->_minLenght);
            return false;
        }
        return true;
    }

    /**
     * (non-PHPdoc)
     * @see My_Validator_Interface#getErrors()
     * @return array
     */
    public function getErrors()
    {
        return $this->_errors;
    }
}

Class My_Contains_Validator implements My_Validator_Interface
{
    protected $_contains = '';

    protected $_errors = array();

    public function __construct($contains = '') {
        $this->_contains = $contains;
    }

    public function isValid($value) {
        if (false === strpos($value, $this->_contains)) {
            $this->_errors[] = sprintf('Input "%s" does not contain "%s"',$value, $this->_contains);
            return false;
        }
        return true;
    }

    /**
     * (non-PHPdoc)
     * @see My_Validator_Interface#getErrors()
     * @return array
     */
    public function getErrors()
    {
        return $this->_errors;
    }
}

Class My_Form
{

    protected $_elements = array();
    protected $_errors = array();

    public function __construct()
    {
        // unimplemented
    }

    /**
     *
     * @param My_Form_Element $element
     */
    public function addElement($element)
    {
        $this->_elements[] = $element;
    }

    /**
     * Data from $_POST, $_GET or something
     * @param array $data
     */
    public function setData($data)
    {
        foreach ($this->_elements as $element)
        {
            foreach($data as $key => $value)
            {
                if ($key == $element->getName())
                {
                    $element->setValue($value);
                    break;
                }
            }
        }
    }

    /**
     *
     * @return boolean
     */
    public function isValid()
    {
        $isValid = true;
        foreach($this->_elements as $element)
        {
            $elementValid = $element->isValid();
            if (false === $elementValid) {
                $isValid = false;
                $this->_errors[$element->getName()] = $element->getErrors();
            }
        }
        return $isValid;
    }

    /**
     *
     * @return array
     */
    public function getErrors()
    {
        return $this->_errors;
    }
}

Abstract Class My_Form_Element
{
    protected $_validators = array();
    protected $_errors = array();
    protected $_name;
    protected $_value;

    /**
     *
     * @param $name
     * @return unknown_type
     */
    public function __construct($name)
    {
        $this->_name = $name;
    }

    public function getName()
    {
        return $this->_name;
    }

    /**
     * @param mixed $value
     */
    public function setValue($value)
    {
        $this->_value = $value;
    }

    public function addValidator($validator)
    {
        $this->_validators[] = $validator;
    }

    public function isValid()
    {
        $isValid = true;
        foreach($this->_validators as $validator) {
            if (!$validator->isValid($this->_value)) {
                $isValid = false;
                $errors = $validator->getErrors();
                foreach ($errors as $error) {
                    $this->_errors[] = $error;
                }
            }
        }
        return $isValid;
    }

    public function getErrors()
    {
        return $this->_errors;
    }

    public function getValue()
    {
        return $this->_value;
    }
}

Class My_Form_Element_Text extends My_Form_Element
{

}


// Creating Form
$myForm = new My_Form();

// Creating Form Elements
$text1 = new My_Form_Element_Text('Feld1');
$text1->addValidator(new My_MinLength_Validator(5));
$text1->addValidator(new My_Contains_Validator('z'));

$text2 = new My_Form_Element_Text('Feld2');
$text2->addValidator(new My_MinLength_Validator(5));
$text2->addValidator(new My_Contains_Validator('u'));

// Adding Elements to form
$myForm->addElement($text1);
$myForm->addElement($text2);

// Filling form with data (in reality this would be $_POST, $_GET or something like that)
$formData = array('Feld1' => 'a',
                  'Feld2' => 'asdfasdf');

$myForm->setData($formData);


// checking if form is valid
if ($myForm->isValid()) {
    echo 'Formular ist valide';
} else {
    // if not -> dump errors
    echo 'Formular ist nicht valide: ';
    var_dump($myForm->getErrors());
}

Output:

Code:

Formular ist nicht valide:

array
  'Feld1' => 
    array
      0 => string 'Input "a" is too short, should be atleast 5 signs long' (length=54)
      1 => string 'Input "a" does not contain "z"' (length=30)
  'Feld2' => 
    array
      0 => string 'Input "asdfasdf" does not contain "u"' (length=37)

Manko10 · 28.12.2008, 13:04

Zitat:

Meine Sicht der Dinge ist nicht so unterschiedlich wie du denkst.

Puhh…

Zitat:

- isPlz() sollte besser isZipCode() heißen?

Die Methode braucht (egal wie sie heißt) auf jeden Fall einen zweiten Parameter, dem ein Ländercode übergeben werden kann. Wer schonmal englische Postleitzahlen gesehen hat, weiß, warum man das machen sollte.

#Avedo · 28.12.2008, 15:24

Hallo!
Danke für deine Hilfe und Mühe robo47. Den ersten Teil mit den Validator-Klassen und dem dazugehörigen Interface verstehe ich sehr gut. Allerdings verstehe ich die Funktionsweise der Form-Klassen nicht wirklich was machen sie wie funktionieren sie? Könntest du mir das etwas genauer erläutern? Wäre sehr nett. Werde mich mal an der einen oder anderen Unterklasse versuchen. Zuvor würde mich aber noch interessieren, ob es nicht auch sinnvoll wäre anstatt eines Validator-Interfaces eine Abstrakte Klasse zu schreiben, von der die einzelnen Validatoren erben. Das ginge da da diese ja nicht noch von anderen Klassen erben sollen. Was meint ihr?
MfG Andy

dr.e. · 28.12.2008, 15:31

Zitat:

Zitat von #Avedo

Zuvor würde mich aber noch interessieren, ob es nicht auch sinnvoll wäre anstatt eines Validator-Interfaces eine Abstrakte Klasse zu schreiben, von der die einzelnen Validatoren erben. Das ginge da da diese ja nicht noch von anderen Klassen erben sollen. Was meint ihr?

Ich verfolge im APF genau diesen Weg und er ist meiner Ansicht nach genauso gültig. Vorteil ist natürlich, dass bereits implementierte Validierungsmöglichkeiten auch in davon abgeleiteten Klassen genutzt werden können. Im Fall der Interfaces muss das u.U. neu implementiert werden, bzw. ist das Konstrukt etwas unhandlicher.

Siehe hierzu Formulare - Verkettung von Filtern.

EDIT 2010: Die Implementierung hinsichtlich Verkettung von Filtern hat sich in der Version 1.11 geändert. Nun können wie auf http://adventure-php-framework.org/S...re-Validatoren beschrieben beliebige Validatoren auf ein Feld gehangen werden.

robo47 · 28.12.2008, 17:25

Zitat:

Zitat von #Avedo

Hallo!
Danke für deine Hilfe und Mühe robo47. Den ersten Teil mit den Validator-Klassen und dem dazugehörigen Interface verstehe ich sehr gut. Allerdings verstehe ich die Funktionsweise der Form-Klassen nicht wirklich was machen sie wie funktionieren sie? Könntest du mir das etwas genauer erläutern? Wäre sehr nett.

Eine Instanz der Formklasse stellt ein Formular dar, es fasst die elemente zusammen und man kann nach dem abschicken ihr $_POST oder $_GET übergeben und über die isValid()-Methode herausfindn ob alle Elemente des Formulars den Anforderungen entsprechen und über getErrors bekommt man dann ein assoziatives array mit den feldnamen als index und einem array der fehlermeldungen für das Feld.

Im Falle des Zend Frameworks sind die Form-Klasse und die Element-Klassen noch um einiges mächtiger, dort wird aus den Objekten direkt der HTML-Code erzeugt.

Im View braucht man dort nur noch:

PHP-Code:

<?php echo $this->form; ?>

Und dort wird dann <form> <input> etwas markup fürs layout (über konfigurierbare Decorators) und auch gleich die Fehlermeldungen generiert.

Themen-Optionen
Druckbare Version zeigen Jemanden per E-Mail auf dieses Thema hinweisen
Thema bewerten
Thema bewerten:

Ähnliche Themen
Thema	Autor	Forum	Antworten	Letzter Beitrag
PHP: Formular Generator	Zergling-new	Tutorials	16	06.07.2010 03:14
Ergebnis von Formular in iFrame zeigen	PsychoEagle	HTML, Usability und Barrierefreiheit	2	22.07.2009 21:07
Problem mit Formular, Daten an datenbank senden	Aurec	PHP Tipps 2008	11	20.11.2008 18:17
Formular Pflichtfelder für Frontpage Formular erstellen	Caruso	JavaScript, Ajax und mehr	5	21.06.2008 09:17
Wert aus Textfeld in neues Formular übernehmen (kein Submit)	PsychoEagle	HTML, Usability und Barrierefreiheit	9	02.01.2007 14:51
formular includen	samspa5	PHP Tipps 2006	13	18.03.2006 11:37
[Erledigt] Formular in Formular		HTML, Usability und Barrierefreiheit	4	19.10.2005 12:18
[Erledigt] PHP Formular ~~wichtig~~		PHP Tipps 2005	27	29.05.2005 19:38
[Erledigt] Im Formular user abfragen?		Datenbanken	3	06.01.2005 10:51
[Erledigt] PHP Formular - Daten an nächsten Schritt weiter geben - Wie?		PHP Tipps 2005	14	02.01.2005 20:05
[Erledigt] Daten in einem Formular ausgeben und ändern		PHP Tipps 2004-2	7	07.12.2004 17:22
Wie implementiere ich mein Email Formular?		PHP Tipps 2004-2	2	14.11.2004 17:02
Brauche PHP Formular		Beitragsarchiv	9	16.08.2004 16:23
[Erledigt] Formular mit Daten werden auf anderer Seite zusammengefasst		PHP Tipps 2004	4	15.08.2004 15:44
[Erledigt] Daten in neuem Formular anzeigen		PHP Tipps 2004	6	21.07.2004 10:44

27.12.2008, 23:33
#Avedo Erfahrener Benutzer Registriert seit: 06.09.2008 Beiträge: 189	Formular Validierung Hallo! Ich habe seit längerem das Problem, dass ich des öfteren Daten aus Formularen überprüfen muss. Dies möchte ich aber möglichst ohne tausende if()-Abfragen und mit einer ausreichenden Fehlermeldung machen. Also habe ich mir überlegt eine Klasse zu schreiben, die diese Aufgabe für mich übernimmt. Leider bin ich mit dem Ergebnis nicht wirklich zufrieden, weiß aber leider auch nicht, wie ich es besser machen soll. Deshalb würde ich mich über Anregungen und Tips freuen. MfG, Andy PHP-Code: <? error_reporting(E_ALL); /*** * Class Validator * * Validator class allows checking * variables for the right content rather * the type. If a given variable is not * of the right type the class will store * an error message into the private class * variable. * * @package Validator * @version 0.1 * @author Andreas Wilhelm <xxxxxxxxxxx@xxxxxx> * @copyright Andreas Wilhelm / class Validator { // private class variables private $errors = array(); / * clear() - Clears the errors array * * @access public * @return NONE / public function clear() { $errors = array(); } /* * isNum() - Checks if the given parameter is numeric * * @access public * @param Mix $param * @param Str $name * @return NONE / public function isNum($param, $name) { if( !is_numeric($param) ) { $this->setError("Invaild {$name}."); } } /* * isInt() - Checks if the given parameter is an integer * * @access public * @param Mix $param * @param Str $name * @return NONE / public function isInt($param, $name) { if( !is_int($param) ) { $this->setError("Invaild {$name}."); } } /* * isFloat() - Checks if the given parameter is a float * * @access public * @param Mix $param * @param Str $name * @return NONE / public function isFloat($param, $name) { if( !is_float($param) ) { $this->setError("Invaild {$name}."); } } /* * isString() - Checks if the given parameter is a string * * @access public * @param Mix $param * @param Str $name * @return NONE / public function isString($param, $name) { if( !is_string($param) ) { $this->setError("Invaild {$name}."); } } /* * isBool() - Checks if the given parameter is a boolean * * @access public * @param Mix $param * @param Str $name * @return NONE / public function isBool($param, $name) { if( !is_bool($param) ) { $this->setError("Invaild {$name}."); } } /* * isArray() - Checks if the given parameter is an array * * @access public * @param Mix $param * @param Str $name * @return NONE / public function isArray($param, $name) { if( !is_array($param) ) { $this->setError("Invaild {$name}."); } } /* * isObject() - Checks if the given parameter is an object * * @access public * @param Mix $param * @param Str $name * @return NONE / public function isObject($param, $name) { if( !is_object($param) ) { $this->setError("Invaild {$name}."); } } /** * isMail() - Checks for valid email addresses * * @access public * @param Mix $param * @return NONE / public function isMail($param) { // set pattern for mail address $pattern = '/^([a-zA-Z0-9])+([\.a-zA-Z0-9_-])@([a-zA-Z0-9_-])+(\.[a-zA-Z0-9_-]+)+/'; // check for mail address if( preg_match($pattern, $param) ) { $this->setError("Invaild email-address."); } } /*** * isMail() - Checks for valid uri * * @access public * @param Mix $param * @param Str $name * @return NONE / public function isUri($param, $name) { // set pattern for uri $pattern = "(http\|ftp\|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#][\w\-\@?^=%&/~\+#])?"; // check for mail address if( preg_match($pattern, $param) ) { $this->setError("Invaild {$name}."); } } /*** * isPlz() - Checks for valid postcode * * @access public * @param Mix $param * @return NONE / public function isPlz($param) { // set pattern for uri $pattern = "^(s-\|S-){0,1}[0-9]{3}\s?[0-9]{2}$"; // check for mail address if( preg_match($pattern, $param) ) { $this->setError("Invaild postcode."); } } /* * equals() - Checks if one entry equals the other * * @access public * @param Mix $param_1 * @param Mix $param_2 * @param Str $name * @return NONE / public function equals($param_1, $param_2, $name) { if( $param_1 !== $param_2 ) { $this->setError("{$name} must be correct two times."); } } /* * length() - Checks the length of a parameter * * @access public * @param Mix $param * @param Str $name * @param Int $max * @param Int $min * @return NONE / public function length($param, $name, $max, $min = 0) { if( !(strlen($param) < $min) ) { $this -> setError("To long {$name}."); } if( !(strlen($param) > $max)) { $this -> setError("To short {$name}."); } } /* * isValid() - Checks if there are any errors * * @access public * @return Boolean / public function isValid() { if( empty($this->errors) ) { return true; } return false; } /* * setError() - Adds an error message to the array * * @access private * @param Str $msg * @return NONE / private function setError($msg) { $this->errors[] = $msg; } /* * __toString() - Returns the errors * * @access public * @return String / public function __toString() { // instance variable that holds return $return = ''; foreach( $this->errors as $error) { $return .= $error . "<br />"; } return $return; } } ?> __________________ I'm so tired of slitting the throats of people calling me a violent psychopath. Geändert von Manko10 (28.12.2008 um 01:18 Uhr). Grund: E-Mail-Adresse unkenntlich gemacht*


Mister Ad PHP Code Flüsterer Registriert seit: 21.08.2005 Beiträge: 4682 PHP-Kenntnisse: Fortgeschritten

28.12.2008, 01:15
Manko10 Supermoderator HD Registriert seit: 16.03.2008 Beiträge: 8.425 PHP-Kenntnisse: Fortgeschritten	Hmm, dazu fällt mir jetzt auch gerade nichts Gescheites ein. Also wenn du keinen Overhead scheust, könntest du pro Formularelement ein Objekt anlegen und die Validierungen als Visitors dranklemmen, aber ob das wirklich das Gelbe vom Ei ist… Was ich dir allerdings empfehlen würde, ist die Formulare auf jeden Fall als Objekte aufzufassen. Der Validator kann dann über diese Objekte iterieren und die Werte validieren. Bei deinem Ansatz ist es bisher so, dass der Validator aus einer Ansammlung von Methoden zur Datenvalidierung besteht, die aber alle von außen angestoßen und mit Werten gefüttert werden müssen. Meiner Meinung nach ist die Validierung aber Aufgabe des Validators und deshalb sollte der Validator selbst auch die Validierung koordinieren. Just my 2 Cents, awaiting Doc's response. P.S. in deinem eigenen Interesse habe ich mal die E-Mail-Adresse aus dem Code entfernt. __________________ Refining Linux Advent Calendar series “24 Outstanding ZSH Gems”

28.12.2008, 01:40
robo47 Moderator Registriert seit: 03.09.2004 Beiträge: 11.798 PHP-Kenntnisse: Fortgeschritten	Also was Form Generierung + Validierung angeht fand ich Zend_Form sehr angenehm das nutzt noch Zend_Validate und Zend_Filter und damit lässt sich sehr schnell und einfach ein formular mit validierung, automatischem platzieren der fehlermeldungen im formular etc realisieren. Ich denke das haupt problem bei deinem beispiel ist, du hast eine Klasse, wenn du ne neue art der validierung willst, musst du die klasse erweitern. Bastel dir ein Interface das z.b. eine methode valid($value) [z.b. weitere noch für getErrors() oder so) und bau darauf alle deine "validatoren" auf. und dann erstellst du eine klasse auf dem interface dem man validatoren mit ner methode übergeben kann, so kannst du mehrere validatoren hinter einen klemmen und schon brauchst du nur noch eine klasse übergeben und machst im hintergrund multiple validierungen. z.b. finde ich isInt auch ... problematisch, ein wert der aus einem formular via post oder get kommt wird NIE ein int sein, auch wenn er nur aus zahlen besteht ist es ein string. numeric währe hier passender. __________________ robo47.net - Blog, Codeschnipsel und mehr \| Caching-Klassen und Opcode Caches in php \| Robo47 Components - PHP Library extending Zend Framework

28.12.2008, 03:34
#Avedo Erfahrener Benutzer Registriert seit: 06.09.2008 Beiträge: 189	Das Zend-Framework kommt leider diesmal nicht mehr in Frage. Musss leider auch gestehen, dass ich nicht so ganz verstehe, was ihr mir da vorschlagt. Kann mir jemand ein kleines Beispiel zeigen? mfG, Andy __________________ I'm so tired of slitting the throats of people calling me a violent psychopath.

28.12.2008, 12:12
robo47 Moderator Registriert seit: 03.09.2004 Beiträge: 11.798 PHP-Kenntnisse: Fortgeschritten	Hier mal ein Beispielcode den ich grad getippt, nicht sonderlich ordentlich, lässt sich noch stark erweitern, nur um das Schema mal zu zeigen was ich meinte, so in "etwa" läuft das ganze auch beim Zend Framework ab nur dass dort noch etwas mehr Funktionalität vorhanden ist. PHP-Code: <?php error_reporting(E_ALL \| E_STRICT); Interface My_Validator_Interface { /** * * @param mixed $value * @return boolean / public function isValid($value); /* * Returns all errors * @return array / public function getErrors(); } Class My_MinLength_Validator implements My_Validator_Interface { protected $_minLenght = 3; protected $_errors = array(); public function __construct($minLenght = 3) { $this->_minLenght = $minLenght; } public function isValid($value) { if (strlen($value) < $this->_minLenght) { $this->_errors[] = sprintf('Input "%s" is too short, should be at least %s signs long',$value, $this->_minLenght); return false; } return true; } /* * (non-PHPdoc) * @see My_Validator_Interface#getErrors() * @return array / public function getErrors() { return $this->_errors; } } Class My_Contains_Validator implements My_Validator_Interface { protected $_contains = ''; protected $_errors = array(); public function __construct($contains = '') { $this->_contains = $contains; } public function isValid($value) { if (false === strpos($value, $this->_contains)) { $this->_errors[] = sprintf('Input "%s" does not contain "%s"',$value, $this->_contains); return false; } return true; } /* * (non-PHPdoc) * @see My_Validator_Interface#getErrors() * @return array / public function getErrors() { return $this->_errors; } } Class My_Form { protected $_elements = array(); protected $_errors = array(); public function __construct() { // unimplemented } /* * * @param My_Form_Element $element / public function addElement($element) { $this->_elements[] = $element; } /* * Data from $_POST, $_GET or something * @param array $data / public function setData($data) { foreach ($this->_elements as $element) { foreach($data as $key => $value) { if ($key == $element->getName()) { $element->setValue($value); break; } } } } /* * * @return boolean / public function isValid() { $isValid = true; foreach($this->_elements as $element) { $elementValid = $element->isValid(); if (false === $elementValid) { $isValid = false; $this->_errors[$element->getName()] = $element->getErrors(); } } return $isValid; } /* * * @return array / public function getErrors() { return $this->_errors; } } Abstract Class My_Form_Element { protected $_validators = array(); protected $_errors = array(); protected $_name; protected $_value; /* * * @param $name * @return unknown_type / public function __construct($name) { $this->_name = $name; } public function getName() { return $this->_name; } /* * @param mixed $value */ public function setValue($value) { $this->_value = $value; } public function addValidator($validator) { $this->_validators[] = $validator; } public function isValid() { $isValid = true; foreach($this->_validators as $validator) { if (!$validator->isValid($this->_value)) { $isValid = false; $errors = $validator->getErrors(); foreach ($errors as $error) { $this->_errors[] = $error; } } } return $isValid; } public function getErrors() { return $this->_errors; } public function getValue() { return $this->_value; } } Class My_Form_Element_Text extends My_Form_Element { } // Creating Form $myForm = new My_Form(); // Creating Form Elements $text1 = new My_Form_Element_Text('Feld1'); $text1->addValidator(new My_MinLength_Validator(5)); $text1->addValidator(new My_Contains_Validator('z')); $text2 = new My_Form_Element_Text('Feld2'); $text2->addValidator(new My_MinLength_Validator(5)); $text2->addValidator(new My_Contains_Validator('u')); // Adding Elements to form $myForm->addElement($text1); $myForm->addElement($text2); // Filling form with data (in reality this would be $_POST, $_GET or something like that) $formData = array('Feld1' => 'a', 'Feld2' => 'asdfasdf'); $myForm->setData($formData); // checking if form is valid if ($myForm->isValid()) { echo 'Formular ist valide'; } else { // if not -> dump errors echo 'Formular ist nicht valide: '; var_dump($myForm->getErrors()); } Output: Code: Formular ist nicht valide: array 'Feld1' => array 0 => string 'Input "a" is too short, should be atleast 5 signs long' (length=54) 1 => string 'Input "a" does not contain "z"' (length=30) 'Feld2' => array 0 => string 'Input "asdfasdf" does not contain "u"' (length=37) __________________ robo47.net - Blog, Codeschnipsel und mehr \| Caching-Klassen und Opcode Caches in php \| Robo47 Components - PHP Library extending Zend Framework

28.12.2008, 15:24
#Avedo Erfahrener Benutzer Registriert seit: 06.09.2008 Beiträge: 189	Hallo! Danke für deine Hilfe und Mühe robo47. Den ersten Teil mit den Validator-Klassen und dem dazugehörigen Interface verstehe ich sehr gut. Allerdings verstehe ich die Funktionsweise der Form-Klassen nicht wirklich was machen sie wie funktionieren sie? Könntest du mir das etwas genauer erläutern? Wäre sehr nett. Werde mich mal an der einen oder anderen Unterklasse versuchen. Zuvor würde mich aber noch interessieren, ob es nicht auch sinnvoll wäre anstatt eines Validator-Interfaces eine Abstrakte Klasse zu schreiben, von der die einzelnen Validatoren erben. Das ginge da da diese ja nicht noch von anderen Klassen erben sollen. Was meint ihr? MfG Andy __________________ I'm so tired of slitting the throats of people calling me a violent psychopath.