Ankündigung

Einklappen
Keine Ankündigung bisher.

Formular Validierung

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • 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


  • #2
    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

    Kommentar


    • #3
      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

      Kommentar


      • #4
        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

        Kommentar


        • #5
          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!
          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

          Kommentar


          • #6
            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

            Kommentar


            • #7
              Meine Sicht der Dinge ist nicht so unterschiedlich wie du denkst.
              Puhh…

              - 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

              Kommentar


              • #8
                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

                Kommentar


                • #9
                  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!
                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                  Kommentar


                  • #10
                    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.net - Blog, Codeschnipsel und mehr
                    | Caching-Klassen und Opcode Caches in php | Robo47 Components - PHP Library extending Zend Framework

                    Kommentar


                    • #11
                      Hallo!
                      Danke für die tolle Hilfe. Wenn ich das nun richtig verstanden habe, Repräsentiert die Formular-Klasse nach der Eingabe das eigentliche HTML-Formular. Man sagt ihr also welche Formularfelder es gibt, welche also später ankommen müssen und wie diese dann validiert werden müssen. So ist es also möglich nach dem Absenden des Formulars das Übergabe Array einfach an die Formularklasse zu übergeben, welche dann überprüft, ob alle Felder, die vorgegeben wurden auch wirklich ausgefüllt sind. Danach werden diese Felder mit Hilfe des angegebenen Validators valdiert. Treten Fehler auf werden diese felderweise in einem Array gespeichert, sodass es zum Beispiel möglich ist, direkt über die entsprechenden Felder die jeweiligen Fehölermeldungen zu schreiben. Habe ich ds alles so richtig verstanden?

                      Mich würde jetzt allerdings noch etwas interessieren. Du meintest es ist möglich sich von einer solchen Klasse auch gleich das Formular erstellen zu lassen. Mich würde interessieren, wie man im allgemeinen HTML-Ausgaben von PHP-Klassen generieren lassen sollte. Ich habe mich nämlich bisher immer an die Norm, so wenig HTML wie möglich (am besten keins) in PHP-Klassen zu verwenden. Allerdings ist es ja schon ganz praktisch, wenn man zum Beispiel Daten aus einer Datenbank tabellarisch darstellen möchte, dies via
                      PHP-Code:
                      <?php
                          
                      // set error-reporting
                          
                      error_reporting(E_ALL);

                          
                      // include class to create tables
                          
                      require_once('Table.php');

                          
                      // instance class
                          
                      $tab = new Table($mysqli$table$fields);

                          
                      // set css class of table
                          
                      $tab->class 'datatab';

                          
                      // set width of table in px
                          
                      $tab->width 500;

                          
                      // print out data table
                          
                      print $tab;
                      ?>
                      zu tun. Eine tägliche Anwendung, die wenn man dies immer und immer wieder Programmieren muss, unnötigen Code produziert und zudem unheimlich nervig ist. Kann mir jemand sagen, wie man solche Ausgaben am geschicktesten in eine Klasse verpackt?

                      Vielen Dank nochmal für eure Hilfe. Dies ist wirklich ein tolles Forum mit einer netten Community und sehr kompetenter Hilfe. Trifft man leider heutzutage nur noch sehr selten. Großes Lob an die verantwortlichen. Freue mich auf eure Antworten.

                      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

                      Kommentar


                      • #12
                        Ich habe mich nämlich bisher immer an die Norm, so wenig HTML wie möglich (am besten keins) in PHP-Klassen zu verwenden.
                        Ich denke, das Problem ist weniger das HTML in einer PHP-Datei, sondern vielmehr das HTML an der falschen Stelle.
                        Solange alles gut gekapselt ist und ausgabespezifische Elemente wirklich nur in geordneter und wiederverwendbarer Weise in View-Komponenten, die als Templates fungieren, enthalten sind, stellt dies nicht das Problem dar.
                        Es ist auch durchaus möglich, die HTML-Teile in Templates abzulegen und dann per PHP in einem DOM-Baum zusammenzufügen. Dabei hast du ähnlich wie in XSLT verschiedene Einzeltemplates, die in den Baum eingefügt werden.
                        Refining Linux: “Performing Push Backups – Part 1: rdiff-backup

                        Kommentar


                        • #13
                          Auch wenn du vorher meintest dass das Zend Framework für dich nicht in Frage, schau dir vielleicht einfach mal die komplette Komponente Zend_Form an, dort ist das ja umgesetzt. Die Zend_Form_Element_* sind dabei die Formular-Elemente dort kannst du direkt schauen wie der Code zusammengesetzt wird und soweiter.
                          robo47.net - Blog, Codeschnipsel und mehr
                          | Caching-Klassen und Opcode Caches in php | Robo47 Components - PHP Library extending Zend Framework

                          Kommentar


                          • #14
                            Du meintest es ist möglich sich von einer solchen Klasse auch gleich das Formular erstellen zu lassen.
                            It depends on the concept. Klassen der View- bzw. UI-Schicht dürfen sicher HTML generieren. Was die Tabelle angeht, so kann man das relativ einfach generisch abbilden um (Datenbank-)Tabellen bzw. Listen auszugeben. Man könnte ein Iterator-Tag basteln, dass eine Liste von Objekten mit seinen Attributen in einer Tabelle ausgibt.

                            Kann mir jemand sagen, wie man solche Ausgaben am geschicktesten in eine Klasse verpackt?
                            Schau dir den Anwendungsfall an und versuche dann aus der Lösung für diesen Fall einen allgemeingültigen abzuleiten. Es kann sinnvoll sein, ein assoziatives Array ausgeben zu können oder wie oben beschrieben eine Liste von Objekten. Sofern du beides ermöglichst, hast du bereits eine Allzweckwaffe. Konfigurationstechnisch sollte die Ausgabe per CSS formatierbar sein (z.B. die verwendeten Klassen mit einem übergebenen Prefix austatten), dann bist du frei in der Verwendung.
                            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!
                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                            Kommentar


                            • #15
                              Hallo!
                              Ich habe noch eine Frage. Sollte man in den Methoden, wie bei der Klasse Form_Element die Methode addValidator(), die Objekte übergeben bekommen nicht überprüfen, ob dieser Validator bereits gesetzt ist und in diesem Fall eine Exception werfen? Es würde natürlich auch ohne gehen, aber das ist ja eigentlich nicht sinn der Sache. Das hieße ja, dass mehrfachzuweisungen unerkannt bleiben. Ich würde diese Methoden also wie folgt ändern:
                              PHP-Code:
                                  /**
                                  * addValidator() - Adds an validator to an element
                                  *
                                  * @access public
                                  * @param Obj $validator
                                  * @return NONE
                                  */
                                  
                              public function addValidator($validator)
                                  {
                                      if( !isset(
                              $this->validators[$validator]) )
                                      {
                                          
                              $this->validators[] = $validator;
                                      }

                                      else
                                          throw new 
                              Exception('Validator was already assigned to this element.');
                                  } 
                              Macht das sinn oder reicht
                              PHP-Code:
                                  /**
                                  * addValidator() - Adds an validator to an element
                                  *
                                  * @access public
                                  * @param Obj $validator
                                  * @return NONE
                                  */
                                  
                              public function addValidator($validator)
                                  {
                                      
                              $this->validators[] = $validator;
                                  } 
                              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

                              Kommentar

                              Lädt...
                              X