Kontaktformular mit PHP

  • Jetzt anmelden. Es dauert nur 2 Minuten und ist kostenlos!

spaceCookie

Mitglied
17 September 2012
133
2
18
Hallo liebe Community. Da die Anfrage in letzter Zeit öfters kam habe ich mich dazu entschlossen ein kleines Tutorial zu schreiben.
Inhalt des Tutorials ist das Schreiben eines Kontaktformulars in PHP.


Das Tutorial richtet sich an Benutzer die schon etwas Erfahrung in PHP haben. Für diese sollte der Code relativ verständlich sein. Nach dem Tutorial werdet ihr dazu in der Lage sein, Formulare dynamisch zu validieren, E-Mails via PHP zu versenden und ihr lernt noch ein bisschen was, was die objektorientierte Programmierung betrifft.

Steigen wir also ein.


1. Die Kontaktformular Klasse


Die Kontaktformular Klasse im folgenden CF-Klasse genannt ist das Herzstück unseres Formulars. Über diese Klasse erfolgt die Erfassung der einzelnen Formularfelder, die Validierung dieser und der Versand der Formulars.


Ich werde den Code der einzelnen Methode der Klasse zunächst vollständig posten und anschließend ein paar Worte dazu sagen. Und nun genug des Geredes steigen wir ein.

Legt in eurem Arbeitsverzeichnis zunächst eine Datei namens ContactForm.class.php an.
Der Code dieser Datei schaut zunächst so aus:


PHP:
class ContactForm{
    /* Attribute */
    private $rules = array();    
    private $data = array();    
    private $errors = array();    
    private $humanKeys = array();
}
Wir deklarieren unsere Klasse welche ContactForm heißt und deklarieren anschließend ein paar Attribute:


$rules: Dieses Attribut enthält später die Regeln welche definieren welche Werte die einzelnen Formularfelder haben dürfen.
$data: Dieses Attribut enthält später die Werte welche der Benutzer über das Formular gesendet hat.
$errors: Falls Fehler bei der Validierung aufgetreten sind enthält dieses Attribut die Fehlermeldungen.
$humanKey: Normalerweise haben Formularfelder Namen welche für den Benutzer nicht gut lesbar sind. Dieses Attribut enthält die entsprechenden Übersetzungen für die User


Der erste Schritt ist getan. Soweit sollte alles Verständlich sein. Der Zugriffsmodifikator private sagt aus dass auf die Attribute nur innerhalb der Klasse zugegriffen werden darf, dazu aber später mehr.

1.1 Der Konstruktor


Der Konstruktor ist eine besondere PHP Methode welche immer dann aufgerufen wird, wenn ein Objekt dieser Klasse erzeugt wird. Unser Konstruktor sieht folgendermaßen aus:


PHP:
public function __construct($rules){    
    $this->rules = $rules;
}
Dem Konstruktor wird der Parameter $rules übergeben. Dieser enthält ein array mit unseren Validierungsregeln. Später bei der Erzeugung unseres Objekts werden wir sehen wie genau dieses Array aussieht. Wichtig ist die einzige Zeile innerhalb des Konstruktors.


Wir weisen unserem Attribut rules (siehe oben) damit den Wert unseres Parameters $rules zu. Das Array mit den Validierungsregeln wird damit in unserer gesamten Klasse verfügbar.


1.2 Eingegebene Userdaten unserer Klasse zur Verfügung stellen


Wir erstellen nun eine Methode mit der wir unserer Klasse die Daten aus dem Formular zur Verfügung stellen. Die Vorgehensweise ist die selbe wie beim Konstruktor, nur dass wir diese Methode, wenn wir sie brauchen manuell aufrufen müssen.


PHP:
public function setData($data){    
    $this->data = $this->sanitizeArray($data);
}
Das Attribut data bekommt den Wert unseres $data Parameters. Auf diesen wird vorher allerdings die Methode sanitizeArray() angewandt damit für einen gewissen Grad an Sicherheit gesorgt wird. Die Methode dazu sieht so aus:


PHP:
private function sanitizeArray($data){
    if(!is_array($data)){
        throw new Exception('Only arrays can be sanitized');
    }
   else{
        foreach($data AS $key => $value){
            $data[$key] = filter_var($value, FILTER_SANITIZE_STRING);
        }
        return $data;
    }
}

Wir übergeben der Methode ein Array mit den Userdaten. Falls kein Array übergeben wird wird für die Fehlerbehandlung eine Exception geworfen. Anschließend durchlaufen wir alle Userdaten und Filtern alle Zeichen heraus die für einen potentiellen Angriff benutzt werden können. Wir geben anschließend das gefilterte Array wieder zurück.


1.3 Formularfeldnamen "humanisieren"


Wie bereits gesagt müssen wir, damit die User wissen um welche Formularfelder es sich im Fehlerfall handelt, diesen einen menschlicheren Namen verpassen. Wir erstellen dazu eine Methode:


PHP:
public function setHumanKeys($wordset){
    if(!is_array($wordset)){
        throw new Exception('Only arrays can be humanized');
    }
    else{
        $this->humanKeys = $wordset;
    }
}
Wir übergeben der setHumanKeys Methode als Parameter ein Array ($wordset) welches später so aussehen wird:
array('html_feldname' => 'Menschlicher Name'). Falls der übergebene Parameter kein Array ist wird für die Fehlerbehandlung eine Exception geworfen.

Ist alles in Ordnung machen wir weiter wie in den letzten Schritten. Unser Klassenattribut humanKeys bekommt den Wert des übergebenen Arrays.

Um nun den humanisierten Namen des Felds zu bekommen brauchen wir eine neue Methode:


PHP:
private function humanize($key){
    if(!isset($this->humanKeys[$key])){
        throw new Exception('For this key ('.$key.') there is no human key');
    }
    else{
        return $this->humanKeys[$key];
    }
}

Auch das ist schnell erklärt. Wir übergeben der Methode den Feldnamen. Wenn zum Feldnamen eine humanisierte Version existiert (wir sie vorher also mit setHumanKeys() gesetzt haben, geben wir diese zurück. Ansonsten werfen wir eine Exception.
 
Zuletzt bearbeitet:

spaceCookie

Mitglied
17 September 2012
133
2
18
1.4 Validieren unseres Formulars

Dies ist wohl der komplexeste Teil unserer Klasse. Aber einmal reingelesen hat man den Hang relativ schnell raus.

Damit später User nicht die Möglichkeiten haben Quatsch in unser Formular einzugeben müssen wir die eingegebenen Werte natürlich validieren.
Die passiert über die Methode vaidate(), welche so aussieht:

PHP:
private function validate(){
    foreach($this->rules AS $fieldname => $rules){
       if(!array_key_exists($fieldname, $this->data)){
           throw new Exception('A field has been set for validation which was not posted');
       }       
       else{
            foreach($rules AS $rule => $value){
                if(is_numeric($rule)){
                    $this->{'cb_'.$value}($fieldname);
                }
                else{
                    $this->{'cb_'.$rule}($fieldname, $value);
                }
            }
        }
   }
}
Code:
foreach($this->rules AS $fieldname => $rules){

Mit dieser foreach-Schleife durchlaufen wir alle deklarierten Regeln. Dieser Schritt ist nötig, damit wir wissen welche Formularfelder validiert werden müssen. Die Regeln haben wir in unserem Klassenattribut rules stehen auf welches wir über $this->rules zugreifen können.

PHP:
if(!array_key_exists($fieldname, $this->data)){
    throw new Exception('A field has been set for validation which was not posted');
}

Auch dieser Teil ist relativ schnell erklärt. Wenn eine Regel gesetzt wurde, die entsprechenden Daten dazu aber fehlen (z.B. wenn das Formularfeld nicht existiert), wird eine Exception geworfen.

PHP:
foreach($rules AS $rule => $value){
    if(is_numeric($rule)){
        $this->{'cb_'.$value}($fieldname);
    }
    else{
        $this->{'cb_'.$rule}($fieldname, $value);
    }
}

Kommen wir nun zum etwas unübersichtlich wirkenden Part. Um diesen zu erklären muss ich etwas weiter ausholen und wir müssen uns ansehen wie die Regeln überhaupt deklariert werden.

Dieser Teil gehört nicht zu unserer Klasse sondern dient nur zum besseren Verständnis. Später wird dieser ausprogrammiert.


PHP:
$form = new ContactForm(array(
    'feld1' => array('alpha', 'min' => 3, 'max' => 20, 'required'),
    'feld2' => array('valid_email'),
));
Später wird so ein neues Objekt der Klasse ContactForm erzeugt. Als Parameter wird ein mehrdimensionales Array mit allen Regeln für die einzelnen Felder übergeben. An diesem Beispiel sehen wir z.B. dass wir zwei Formularfelder zum validieren haben. feld1 und feld2. Diese haben als Wert wiederum ein Array mit den eigentlichen Regeln. feld1 darf z.B. nur alphabetische Zeichen haben. Außerdem muss es zwischen 3 (min) und 20 (max) Zeichen haben. Zusätzlich darf das Feld
nicht leer sein (required).

feld2 muss hier in unserem Beispiel eine gültige E-Mail Adresse sein. Das wichtige dass ihr euch an dieser Sache merken solltet ist, dass es Regeln gibt die einen Wert haben (min, max) und Regeln ohne Wert (alpha, required, valid_email).
Regeln ohne Wert haben einen numerischen Index, Regeln mit Wert sind assoziativ. Das erste Array sähe so aus:

Code:
[FONT=arial][0] => 'alpha'[/FONT]
[FONT=arial][min] => 3[/FONT]
[FONT=arial][max] => 20[/FONT]
[FONT=arial][1] => 'required'[/FONT]
Soviel dazu. Warum dass wichtig ist erfahren wir gleich, denn nun beenden wir unseren kleinen Exkurs und gehen zurück an die Klasse. Wir waren bei folgendem Code stehengeblieben:

PHP:
foreach($rules AS $rule => $value){
    if(is_numeric($rule)){
        $this->{'cb_'.$value}($fieldname);
    }
    else{
        $this->{'cb_'.$rule}($fieldname, $value);
    }
}


Was wir hier haben ist eine verschachtelte Foreach Schleife. Wir befinden uns (werft mal einen Blick nach oben) immer noch in der anderen Schleife

Code:
foreach($this->rules AS $fieldname => $rules){

in $fieldname haben wir den Name des HTML Felds und in [/b]$rules[/b] das Array mit den Regeln. Was wir in der zweiten Foreach-Schleife machen,
ist einfach das Array mit den Regeln durchlaufen.

Der Index steht hierbei in $rule und der Wert in $value. So. Nun etwas den Grips anstrengen:

PHP:
if(is_numeric($rule)){
    $this->{'cb_'.$value}($fieldname);
}
Wir fragen ab, ob der Index numerisch ist. Ihr erinnert euch (Regeln ohne Wert haben einen numerischen Index)?
Wenn dies der Fall ist, rufen wir eine Methode auf, welche die Validierung für uns übernimmt. Der Methodenaufruf erfolgt dynamisch, da wir ja nicht wissen welche Regeln auf das Feld angewandt wurden.

PHP:
$this->{'cb_'.$value}($fieldname);
Weil der Index numerisch ist, müssen wir eine Methode mit dem Namen des Werts aufrufen. Angenommen wir würden die Regel required anwenden, so würde diese Zeile übersetzt lauten:

PHP:
$this->cb_required($fieldname)
Der Methode übergeben wir den Feldnamen. Die Methode prüft dann intern ob das Feld einen gültigen Wert enthält oder nicht. Dazu aber später.

Kommen wir nun zum else Fall, welcher eintritt wenn der Index nicht numerisch ist (z.B. bei min oder max

PHP:
else{
    $this->{'cb_'.$rule}($fieldname, $value);
}
Hier machen wir fast dasselbe. Nur rufen wir die Methode nicht mit dem Wert des Arrayelements auf, sondern mit dem Name des Index. Beispiel:
Die Regel wäre min => 3. Die Zeile würde übersetzt lauten:

PHP:
$this->cb_min($fieldname, $value);
Wir sehen, wir haben neben dem Feldname einen zweiten Parameter. Dieser gibt den Wert zum Vergleich an. Also in diesem Beispiel die Mindestzeichenlänge: 3.
In der Methode wird der Wert des Feldes dann mit diesem zweiten Parameter verglichen.

Das wars auch schon. Viel mehr gibts dazu nicht zu sagen.
 
Zuletzt bearbeitet:

spaceCookie

Mitglied
17 September 2012
133
2
18
1.5 Callback Methoden

Im letzten Kapitel haben wir uns darum gekümmert, die Regeln für die Validierung an die richtigen Methoden zu deligieren. Nun sehen wir uns an wie eine solche Methode zur Validierung aussieht. Als Beispiel ziehen wir wieder unser bekanntes min heran.

Wir legen also eine neue Methode an:

PHP:
private function cb_min($key, $val){
    if(strlen($this->data[$key]) >= $val)
        return true;
    $this->setError($key, $this->humanize($key).' muss mindestens '.$val.' Zeichen beinhalten');
   return false;
}
Wir sehen zu allererst, dass unsere Methode den präfix cb_ (für Callback) hat. Dies habe ich darum so gehandhabt, damit man diese Validierungsmethoden von anderen Methoden der Klasse unterscheiden kann. Das was folgt (min) ist der Name der Regel. Wenn eine Regel existiert muss es dazu auch die entsprechende Callback Methode geben ( min -> cb_min(), max -> cb_max(), hallowelt -> cb_hallowelt() ). Der Parameter $key enthält den Namen des Feldes welches validiert werden soll, der Parameter $val enthält den Vergleichswert.

PHP:
if(strlen($this->data[$key]) >= $val)
        return true;
Hier findet die eigentliche Prüfung des Inhalts statt. Wir wollen prüfen ob das Formularfeld eine bestimmte mindeslänge hat also nehmen wir die Funktion strlen() die uns die Anzahl der Zeichen eines Strings zurückliefert. Der String ist in diesem Falle das, was der User ins Formular eingegeben hat. ($this->data[$key]). Wir erinnern uns, wir haben vorhin mit der setData() Methode die Usereingaben in unser Klassenattribut data verschoben. Wir holen uns also den Wert aus dem Feld $key welches dem übergebenen Feldnamen entspricht.

Falls dieser größer oder gleich dem Vergleichswert $val ist geben wir true zurück und verlassen die Methode. Der eingegebene Wert für das Feld ist gültig. Nun aber zum Fehlerfall:

PHP:
$this->setError($key, $this->humanize($key).' muss mindestens '.$val.' Zeichen beinhalten');    return false;
Falls der eingegebene Wert kleiner dem Vergleichswert ist, wird die Methode setError() aufgerufen welche wir später ausprogrammieren werden. Diese Methode bekommt als ersten Parameter den Feldnamen und als zweiten die Fehlermeldung.

Wie wir sehen kümmern sich unsere Callback Methoden garnicht um die Fehlerbehandlung sondern deligieren die Fehlermeldung lediglich.

Ihr könnt Callback Methoden nun erweitern wie ihr wollt. Legt dazu lediglich die entsprechenden Methoden an, mehr müsst ihr nicht tun. Ich habe weitere Methoden angelegt die ich euch am Ende der Erklärung zeige. Diese sind selbsterklärend aber ich habe die Funktion hereinkommentiert. Aber eins nach dem anderen. Kümmern wir uns erstmal um die Fehlerbehandlung.



1.6 Fehlerbehandlung

Wir haben im letzten Kapitel gesehen, dass sich die Methode setError() um die Fehlerbehandlung kümmert.
Programmieren wir diese aus:

PHP:
private function setError($key, $message){
    $this->errors[$key] = $message;
}
Eine Zeile! Mehr brauchen wir in diesem Fall nicht. Ihr erinnert euch an unser Klassenattribut errors.
Wir fügen diesem Array lediglich ein neues Element hinzu. Der Index ist der Feldname und der Wert die Fehlermeldung.

So. Wir sind nun fast fertig mit unserer Klasse. Nur noch sechs Methoden.



1.7 Überprüfen und senden des Formulars
Nun, da wir mit der Fehlerbehandlung und mit der Validierung fertig sind, können wir uns langsam daran machen und unser Formular absenden. Dazu legen wir die Methode send() an.

PHP:
public function send($subject, $from, $to){
    $this->validate();
    if($this->isValid()){
        $this->emailMessage($subject, $from, $to);
        return true;
    }
    return false;
}
Wir übergeben den Titel der E-Mail, eine Empfänger- sowie eine Absenderadresse an die Methode und rufen anschließend die validate() Methode auf. Diese haben wir bereits oben ausprogrammiert (1.3). Anschließend fragen wir via isValid() ab ob keine Fehler bei der Validierung aufgetreten sind.

Die Methode isValid() sieht folgendermaßen aus:

PHP:
public function isValid(){
    if(empty($this->errors) && !empty($_POST))
        return true;
    return false;
}
Wir überprüfen ob unser Klassenattribut errors, ein Array mit allen Fehlermeldungen, leer ist und ob überhaupt etwas via $_POST versendet wurde. Wenn beide Fälle zutreffen sind keine Fehler aufgetreten und die eingabe ist valide. Andernfalls geben wir false zurück. Es sind also Fehler aufgetreten.

Zuruück zur send() Methode. Wenn also alles in Ordnung ist versenden wir die E-Mail mit unserer Methode emailMessage() und geben true zurück. Ansonsten war der Versand nicht erfolgreich und wir geben false zurück.


1.8 Versand der E-Mail

Fast geschafft. Wenn alles richtig gelaufen ist, muss natürlich eine E-Mail versand werden. Hierzu schreiben wir die Methode emailMessage()

PHP:
private function emailMessage($subject, $from, $to){   $sendstring = '';
    foreach($this->rules AS $fieldname => $value){
        if(!in_array('not_allowed', $value)){
            $sendstring .= $this->humanize($fieldname).': '.$this->data[$fieldname].'<br />';
        }
    }
   $text = $sendstring;
   $headers = 'From: '.$from.' <'.$to.'>\n';
    $headers .= 'Content-Type: text/html\n';
    $headers .= 'Content-Transfer-Encoding: 8bit\n';
   try{
        mail($to, $subject, $text, $headers);
    }   
   catch(Exception $e){
        $e->getMessage();
    }
}


Die Parameter der Methode sind selbsterklärend. Wir steigen also direkt ein. $sendstring enthält später den Text der versendet wurde, ist zunächst aber ein leerer String.

Wir durchlaufen all unsere Regeln in der Foreach Schleife (alle Felder die Regeln haben müssen auch mit der E-Mail versendet werden). Anschließend fragen wir ab ob es in unseren Regeln die Regel not_allowed gibt. Dies ist eine callback Methode die ich geschrieben habe. Sie ist lediglich ein Honeypot. Es ist ein Feld dass nicht ausgefüllt werden darf, folglich muss es auch nicht mit der E-Mail versendet werden.

Dann hängen wir unserem String noch den humanisierten Feldnamen und dessen Wert an.

Der Rest des Codes kümmert sich nur noch um den Versand der E-Mail.

Der code nach der foreach-Schleife ist ziemlich provisorisch. Die Fehlerbehandlung passt nicht ganz (dazu später mehr) und
es sollte zum versenden von E-Mails eine Mailerklasse benutzt werden, damit die Mails auch wirklich immer ankommen.
 
Zuletzt bearbeitet:

spaceCookie

Mitglied
17 September 2012
133
2
18
1.9 Extra Candy
Nun, wir sind im groben durch mit unserer Klasse. Da gibt es aber noch zwei Dinge die uns fehlen. Die erste wichtige Sache ist. Wir speichern Fehlermeldungen zwar ab, stellen aber keine Methode bereit um diese zurückzuliefern. Der User soll schließlich wissen was er falsch gemacht hat.

Hierzu legen wir unsere vorletzte Methode getErrors() an. Diese liefert uns lediglich unser Array mit allen Fehlermeldungen zurück. Um die Darstellung muss sich die Klasse nicht kümmern und das ist auch gut so.

PHP:
public function getErrors(){
    return $this->errors;
}
Kommen wir zur zweiten Sache. Jeder Benutzer hasst es, wenn im Fehlerfall bei einer Formulareingabe alle Felder neu ausgefüllt werden müssen.
Stattdessen sollten Felder die korrekt eingegeben wurden im Fehlerfall beibehalten werden. Darum kümmert sich unsere Methode repopulate()

PHP:
public function repopulate($field){
    if(!array_key_exists($field, $this->errors) && isset($_POST[$field])){
        return $_POST[$field];
    }
    else{
        return "";
    }
}
Der Methode wird der Feldname übergeben. Anschließend wird geprüft ob zu diesem Feldname ein Eintrag in unserem Fehlerattribut (errors) existiert und
ob das Feld überhaupt gesendet wurde. Wenn es kein Fehler in diesem Feld gibt und das Feld ausgefüllt wurde, geben wir den alten Wert den der User eingegeben hat
zurück. Ansonsten einen leeren String.


1.10 Nachwort

Unsere Klasse ist fertig und bereit für den Einsatz. Natürlich müssen wir noch ein paar Zeilen schreiben. Es kommt aber nichts Weltbewegendes mehr.
Ich habe für dieses Tutorial die interne Fehlerbehandlung etwas vernachlässigt (Exceptions werden z.B. nicht gefangen).
Diese würde ich gerne zu einem späteren Zeitpunkt noch einmal aufmotzen und das Tutorial dann updaten.

Die fertige Klasse findet ihr hier: #5131369 - Pastie
 
Zuletzt bearbeitet:

spaceCookie

Mitglied
17 September 2012
133
2
18
2.0 Die process_form.php

Nachdem unsere Klasse nun einsatzbereit ist, sollten wir diese natürlich auch einsetzen. Wir legen uns also eine neue Datei namens process_form.php an.
Ich zeige zunächst den gesamten Code:

PHP:
<?php
include 'ContactForm.class.php';
$form = new ContactForm(array(
    'salutation' => array('only' => array('Herr', 'Frau')),
    'first_name' => array('alpha', 'min' => 3, 'max' => 20, 'required'),
    'last_name' =>  array('alpha', 'min' => 3, 'max' => 20, 'required'),
    'mail' =>  array('valid_email', 'required'),
    'message' =>  array('alpha', 'min' => 3, 'max' => 500, 'required'),
    'email' =>  array('not_allowed'),
));
$form->setHumanKeys(array(
    'salutation' => 'Anrede',
    'first_name' => 'Vorname',
    'last_name' => 'Nachname',
    'mail' => 'E-Mail',
    'message' => 'Nachricht',
    'email' => 'Honeypot',
));
if(isset($_POST['send_form'])){
    $form->setData($_POST);
    if(!$form->send('Kontaktanfrage', 'Mein persönliches Kontaktformular', 'adresse@domain.de')){
        $errors = $form->getErrors();
    }
    else{
        $success = true;
    }
}?>

Zunächst inkludieren wir unsere Klasse via include Befehl, damit wir sie auch benutzen können.
Anschließend erzeugen wir eine Instanz unserer ContactForm Klasse und übergeben die nötigen Regeln.
Der Index der Arrayelemente ist jeweils der Feldname. Der Wert ist ein Array mit den Regeln.
Dazu vielleicht ein paar Worte:

only: Das Feld muss einen bestimmten Wert enthalten der im mitgegebenen Array ebenfalls enthalten ist.
alpha: Das Feld darf nur alphabetische Zeichen enthalten.
min: Das Feld muss mindestens X Zeichen haben.
max: Das Feld darf höchstens X Zeichen haben.
required: Das Feld darf nicht leer sein.
valid_email: Das Feld muss eine gültige E-Mail Adresse enthalten.
not_allowed: Das Feld darf nicht ausgefüllt werden.

Alle diese Regeln sind als Callback Methoden in unserer CF-Klasse enthalten. Werft einen Blick auf den oben geposteten Link.
PHP:
$form->setHumanKeys(array(
    'salutation' => 'Anrede',
    'first_name' => 'Vorname',
    'last_name' => 'Nachname',
    'mail' => 'E-Mail',
    'message' => 'Nachricht',
    'email' => 'Honeypot',));

Hiermit weisen wir unseren Formularfeldern lediglich menschliche Namen zu. Wir übergeben ein Array mit dem HTML Feldnamen als Index und dem menschlichen Namen als Wert.

PHP:
if(isset($_POST['send_form'])){
    $form->setData($_POST);
    if(!$form->send('Kontaktanfrage', 'Mein persönliches Kontaktformular', 'adresse@domain.de')){
        $errors = $form->getErrors();
    }
    else{
        $success = true;
    }
}

Der letzte Part unserer Datei. Wir überprüfen, ob dass Formular abgesendet wurde. Wenn ja übergeben wir die gesendeten Daten an unser Objekt und
senden das Formular anschließend ab. Unser Objekt prüft dann ob die Formular abgesendet werden kann. Wenn ja tut es das, andernfalls schieben wir
alle Fehlermeldungen in das $errors Array.

Soviel dazu. Mehr braucht es in dieser Datei nicht. Kommen wir zum letzten Schritt. Dem HTML.
 
Zuletzt bearbeitet:

spaceCookie

Mitglied
17 September 2012
133
2
18
3.0 Der HTML-Part


Wir sind quasi am Ende angelangt. Zum HTML werde ich nicht viel sagen.
Ich setze voraus dass man etwas mit HTML anfangen kann. Diejenigen die das können bedürfen
auch nicht viel Erklärung. Ein paar Sachen gibt es aber doch dazu.


PHP:
include 'process_form.php';
Wir binden zunächst unsere vorher erstellte process_form.php ein.


PHP:
<?php if(isset($errors)): ?>
    <ul class="error message">
        <?php foreach($form->getErrors() AS $error): ?>
            <li><?=$error?></li>
        <?php endforeach; ?>
    </ul>
<?php elseif(isset($success)): ?>
    <ul class="success message">
        <li>Ihr Formular wurde erfolgreich gesendet</li>
    </ul>
<?php endif; ?>

Hierzu bedarf es evtl. noch einiger Erklärung. Falls Fehler aufgetreten sind ($errors, siehe process_form.php) werden diese in einer Foreach-Schleife ausgegeben.
Ansonsten wird abgefragt ob das Formular erfolgreich abgesendet werden konnte (siehe process_form.php) und es wird eine Erfolgsmeldung ausgegeben.


Noch eine Sache zu den einzelnen Formularfeldern.


PHP:
<td><input type="text" name="first_name" value="<?=$form->repopulate('first_name')?>" /></td>

Ziehen wir dieses Feld als Beispiel heran. Die Sache die ich erklären möchte ist das value Attribut. Ihr seht dass wir
die Methode repopulate unseres Objekts aufrufen und als Parameter den Feldnamen übergeben. Werft nochmal einen Blick auf (1.7).
Falls kein Fehler beim letzten Absenden aufgetreten ist, wird der Inhalt der letzten Eingabe in das Feld geschrieben, ansonsten ist das Feld leer.




HTML:
<?php
ERROR_REPORTING(E_ALL);
include 'process_form.php';?>
<!DOCTYPE html>
<html>
    <head>
        <title>Mein Kontaktformular</title>
        <link rel="stylesheet" type="text/css" href="css/screen.css" />
    </head>
    <body>
        <div id="wrapper">
                <?php if(isset($errors)): ?>
                    <ul class="error message">
                        <?php foreach($form->getErrors() AS $error): ?>
                            <li><?=$error?></li>
                        <?php endforeach; ?>
                    </ul>
                <?php elseif(isset($success)): ?>
                    <ul class="success message">
                        <li>Ihr Formular wurde erfolgreich gesendet</li>
                    </ul>
                <?php endif; ?>
             <form action="" method="POST">
              <fieldset>
                <legend>Kontaktdaten</legend>
                <table class="form-table">
                    <tr>
                        <td>Anrede:</td>
                        <td>
                            <select name="salutation">
                                <option>Herr</option>
                                <option>Frau</option>
                            </select>
                        </td>
                     </tr>
                     <tr>
                        <td>Vorname:</td>
                        <td><input type="text" name="first_name" value="<?=$form->repopulate('first_name')?>" /></td>
                     </tr>
                     <tr>
                        <td>Nachname</td>
                        <td><input type="text" name="last_name" value="<?=$form->repopulate('last_name')?>" /></td>
                     </tr>
                     <tr>
                        <td>E-Mail</td>
                        <td><input type="text" name="mail" value="<?=$form->repopulate('mail')?>" /></td>
                     </tr>
                     <tr>
                        <td>Ihre Nachricht</td>
                        <td>
                            <textarea name="message"><?=$form->repopulate('message')?></textarea>
                        </td>
                     </tr>
                     <tr class="hidden">
                         <td rowspan="2"><input type="text" name="email" /></td>
                     </tr>
                     <tr>
                         <td rowspan="2"><input type="submit" name="send_form" /></td>
                     </tr>
                 </table>
             </fieldset>
         </form>
     </div>    
 </body>
</html>

Das wars auch schon. Wir sind am Ende unseres "kleinen" Tutorials und ich hoffe es war aufschlussreich.
Für diejenigen die schlichtweg keine Lust haben sich Meterlangen Text anzutun habe ich die kompletten Tutorialdateien gezippt in den Anhang geworfen.


An die anderen die sich das Tutorial wirklich durchgelesen haben:
Ich weiß es mag ein zäher Brocken sein, besonders als Anfänger. Aber es lohnt sich, sich da durchzubeißen weil man dabei meiner Meinung nach vieles lernen kann.
Falls etwas unklar ist, bin ich gerne dazu bereit das Tutorial entsprechend zu überarbeiten. Dazu freue ich mich über jegliches Feedback.
 

Asterixus

Aktives Mitglied
15 Dezember 2007
1.303
14
38
26
Belgien
Nimm's mir nicht übel, aber das wirkt so, als hättest du gerade Klassen in PHP entdeckt und meinst, dass es professionell wirkt, das so zu machen.
Aber einiges in deinem Tutorial ist nicht wirklich korrekt.

FILTER_SANITIZE_STRING? Wozu? Was ist, wenn das Ziel des Formulars ist, HTML zu senden? Warum sollte ein Benutzer nicht HTML eingeben dürfen? Im Übrigen ist eine Iteration nicht nötig, dafür gibt es schon filter_var_array().
Deine Klasse ermöglicht nicht, Checkboxen im Formular zu benutzen.
In der Klasse selbst benutzt du direkt $_POST und übergibst das Array erst. Wozu? Wenn man ein doppeltes Anführungszeichen eingibt, wird das wieder ins Formular kommen und invalides HTML erzeugen, falls das Formular nochmal angezeigt wird.
Warum benutzt du die Funktion mail() und benutzt sie auch noch nicht einmal gut?
 
Werbung: