php.de

Zurück   php.de > Webentwicklung > Software-Design

Software-Design Diskussionen auf Profi-Niveau: PHP Lösungen auf konzeptioneller Ebene

Antwort
 
LinkBack Themen-Optionen
Alt 27.12.2008, 23:33  
Erfahrener Benutzer
 
Registriert seit: 06.09.2008
Beiträge: 189
#Avedo befindet sich auf einem aufstrebenden Ast
Standard 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\-\.,@?^=%&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;
    }
}
?>
__________________
Andreas Wilhelm BSc. Applied Computer Science Follow my blog! http://www.avedo.net Follow me on Google Plus! https://plus.google.com/u/0/109348079906250336178 Support me on Flattr! https://flattr.com/profile/avedo

Geändert von Manko10 (28.12.2008 um 01:18 Uhr). Grund: E-Mail-Adresse unkenntlich gemacht
#Avedo ist offline   Mit Zitat antworten
Sponsor Mitteilung
PHP Code Flüsterer

Registriert seit: 21.08.2005
Beiträge: 4682
PHP-Kenntnisse:
Fortgeschritten

Alt 28.12.2008, 01:15  
Supermoderator HD
 
Registriert seit: 16.03.2008
Beiträge: 9.213
PHP-Kenntnisse:
Fortgeschritten
Manko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes Ansehen
Standard

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: “Performing Push Backups – Part 1: rdiff-backup
Manko10 ist offline   Mit Zitat antworten
Alt 28.12.2008, 01:40  
Moderator
 
Registriert seit: 03.09.2004
Beiträge: 11.788
PHP-Kenntnisse:
Fortgeschritten
robo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz sein
Standard

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 ist offline   Mit Zitat antworten
Alt 28.12.2008, 03:34  
Erfahrener Benutzer
 
Registriert seit: 06.09.2008
Beiträge: 189
#Avedo befindet sich auf einem aufstrebenden Ast
Standard

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
__________________
Andreas Wilhelm BSc. Applied Computer Science Follow my blog! http://www.avedo.net Follow me on Google Plus! https://plus.google.com/u/0/109348079906250336178 Support me on Flattr! https://flattr.com/profile/avedo
#Avedo ist offline   Mit Zitat antworten
Alt 28.12.2008, 11:19  
Moderator und Wett-König
 
Registriert seit: 21.05.2008
Beiträge: 3.753
PHP-Kenntnisse:
Fortgeschritten
dr.e. ist ein wunderbarer Anblickdr.e. ist ein wunderbarer Anblickdr.e. ist ein wunderbarer Anblickdr.e. ist ein wunderbarer Anblickdr.e. ist ein wunderbarer Anblickdr.e. ist ein wunderbarer Anblick
Standard

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?
__________________
Viele Grüße,
Dr.E.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1. Think about software design before you start to write code!
2. Discuss and review it together with experts!
3. Choose good tools (-> Adventure PHP Framework (APF))!
4. Write clean and reusable software only!
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
dr.e. ist offline   Mit Zitat antworten
Alt 28.12.2008, 12:12  
Moderator
 
Registriert seit: 03.09.2004
Beiträge: 11.788
PHP-Kenntnisse:
Fortgeschritten
robo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz sein
Standard

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 ist offline   Mit Zitat antworten
Alt 28.12.2008, 13:04  
Supermoderator HD
 
Registriert seit: 16.03.2008
Beiträge: 9.213
PHP-Kenntnisse:
Fortgeschritten
Manko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes AnsehenManko10 genießt hohes Ansehen
Standard

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.
__________________
Refining Linux: “Performing Push Backups – Part 1: rdiff-backup

Geändert von Manko10 (28.12.2008 um 13:09 Uhr).
Manko10 ist offline   Mit Zitat antworten
Alt 28.12.2008, 15:24  
Erfahrener Benutzer
 
Registriert seit: 06.09.2008
Beiträge: 189
#Avedo befindet sich auf einem aufstrebenden Ast
Standard

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
__________________
Andreas Wilhelm BSc. Applied Computer Science Follow my blog! http://www.avedo.net Follow me on Google Plus! https://plus.google.com/u/0/109348079906250336178 Support me on Flattr! https://flattr.com/profile/avedo
#Avedo ist offline   Mit Zitat antworten
Alt 28.12.2008, 15:31  
Moderator und Wett-König
 
Registriert seit: 21.05.2008
Beiträge: 3.753
PHP-Kenntnisse:
Fortgeschritten
dr.e. ist ein wunderbarer Anblickdr.e. ist ein wunderbarer Anblickdr.e. ist ein wunderbarer Anblickdr.e. ist ein wunderbarer Anblickdr.e. ist ein wunderbarer Anblickdr.e. ist ein wunderbarer Anblick
Standard

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.
__________________
Viele Grüße,
Dr.E.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1. Think about software design before you start to write code!
2. Discuss and review it together with experts!
3. Choose good tools (-> Adventure PHP Framework (APF))!
4. Write clean and reusable software only!
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Geändert von dr.e. (28.06.2010 um 17:04 Uhr). Grund: Entfernung toter Link.
dr.e. ist offline   Mit Zitat antworten
Alt 28.12.2008, 17:25  
Moderator
 
Registriert seit: 03.09.2004
Beiträge: 11.788
PHP-Kenntnisse:
Fortgeschritten
robo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz seinrobo47 kann auf vieles stolz sein
Standard

Zitat:
Zitat von #Avedo Beitrag anzeigen
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.
robo47 ist offline   Mit Zitat antworten
Antwort


Themen-Optionen


Ä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
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

Besucher kamen über folgende Suchanfragen bei Google auf diese Seite
php formular validierung, php formular validieren, formularvalidierung php, formular validierung php, formular validieren php, formular validierung, php validierung formular, php form validation, formulare validieren, php formulare validieren, php form validierung, php formularvalidierung, formular validieren, php formulardaten validieren, formularvalidierung mit php, php form validieren, php formular validation, form validierung php, validierung formular, formularvalidierung

Alle Zeitangaben in WEZ +2. Es ist jetzt 20:29 Uhr.




Powered by vBulletin® Version 3.7.2 (Deutsch)
Copyright ©2000 - 2014, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO 3.2.0
Aprilia-Forum, Aquaristik-Forum, Liebeskummer-Forum, Zierfisch-Forum, Geizkragen-Forum