Totorial/Workshop zum Thema Formmailer (Teil 2)
Soweit so gut. Ich hoffe HTML ist klar. Jetzt haben wir alles was wir brauchen in einer HTML-Datei. Damit das
aber verschickt wird, brauchen wir ein Script. In diesem Fall ein PHP-Script. Das nennen wir z.B. "mailer.php". In
diesem Script müssen die Angaben verwaltet werden, was wir auch gleich machen. Aber in unserer HTML-Datei
fehlt noch etwas... und zwar weiß die Datei nicht, wohin die Daten gesendet werden müssen, die der Besucher
einträgt. Das kann man in dem HTML-Tag "FORM" in Zeile 8 editieren. Und zwar füllen wir das Attribut
ACTION="" mit dem Wert "mailer.php" und speichern anschließend die HTML-Datei ab.
Jetzt wo wir die HTML-Datei fertig haben, können wir die "mailer.php"-Datei beschreiben. Zuerst machen wir mit
PHP eine Abfrage, ob die Daten angekommen sind oder nicht. Damit wird vermieden, dass man einfach die Datei
"mailer.php" im Browser aufruft und somit wahrscheinlich auch leere Anfragen sendet. Leere Anfragen lassen wir
aber nicht zu, da wir die einzelnen Felder überprüfen werden. Allerdings ist es trotzdem besser die Anfrage am
Anfang zu machen. Dafür eignet sich der Submit-Button gut. Wenn wir diesen Button anklicken, werden die
angegebenen Daten von der HTML-Datei mit dem Formular an das PHP-Script gesendet. Da der Submit-Button
auch zum FORM-Tag gehört, enthällt er zwar keinen Wert wie z.B. Editfield aber er ist vorhanden (definiert) und
kann somit auf die Existens hin abgefragt werden. Falls aber der Submit-Button nicht angeklickt wurde und
somit auch nicht definiert ist, wird die Ausführung des Codes gar nicht weiter ausgeführt. Diese Hauptabfrage
hat nur eine Sache zu überprüfen und ist somit auch recht schnell.
PHP-Code:
<?PHP
// Unsere PHP-Datei
if (isset($_POST['submit'])) // Unsere Hauptanfrage
{
// ... hier wird später unser Code hinkommen
}
?>
Erklärung:
- Mit der sogenannten if-Abfrage prüft man einen Ausdruck, der einen Wert zurückgibt. In diesem Fall ist dieser
Ausdruck der Rückgabewert der Funktion isset(). Die Funktion isset() gibt entweder true oder false zurück. true
und false sind Werte des Datentyps bool. Dieser Datentyp unterscheidet nur zwei Werte (nähmlich true und
false oder anders gesagt 1 und 0). Man kann eine Variable vom Typ bool definieren ($var = true; oder $var =
1; ) oder einen Ausdruck erstellen! Bei der if-Abfrage kommt auch ein boolischer Wert raus. Das heißt bool ist
zweiseitig zu verstehen und ist somit auch ein besonderer Datentyp.
- die Funktion isset() hat die Aufgabe eine Variable (Objekt), die man als Argument übergibt auf die Existens zu
prüfen. Falls die übergebene Variable tatsächlich definiert ($var = ""; // eine Variable vom Typ string wurde
erstellt/definiert) wurde, hat man als Rückgabetyp der Funktion den boolischen Wert true/1 oder eben false/0
falls die Variable/Objekt nicht vorhanden sind. Mit diesem "Trick" kann man schnell feststellen ob der
Submit-Button angeklickt wurde.
Grundsätzliches zu Funktionen:
Funktionen sind genau betrachtet kleine Programme in einem Hauptprogramm/Script, die man aufrufen kann und die
evtl. einen Rückgabewert zurückliefern. Eine Funktion kann man auch als Fließband vorstellen: man gibt ihm eine
Aufgabe oder in unserem Fall ruft man die Funktion auf und am Ende hat man entweder einen fertigen Mercedes oder
einen Rückgabewert. Jenachdem was man sich wünscht.
- Als Argument in der isset()-Funktion haben wir keine einfache Variable stehen, sondern $_POST['submit']. Das heißt,
dass wir ein Array(dt. Vektor) mit bestimmtem Wert im Index (Index eines Arrays wird in den []-Klammern angegeben)
ansprechen.
Grundsätzliches zu Arrays:
Ein Array ist nichts anderes als eine Sammlung von Werten gleichen Datentyps. Man kann ein Array bei PHP nummerisch
ansprechen ($arr[0]...) wie auch wörtlich ($_POST['submit']). Um ein selbsterstelltes Array wörtlich anzusprechen,
muss man in der Definition jedem Wert eine eindeutige Bezeichnung verpassen. ($array = array("eins" => 1, "zwei" =>
2, "drei" => 3); // hier kann ich jetzt ein Array wörtlich ansprechen: echo $arr['eins']; // gibt 1 aus)
Was für Array ist $_POST?
$_POST[] ist eins von den superglobalen Arrays, die es seit der 4. Version gibt (früher hieß es $HTTP_POST_VARS[]...).
Genauer gesagt enthällt dieses Array alle Werte, die man per POST an ein PHP-Script überträgt. POST selbst ist eine
Methode des HTTP und wird verwendet, um Daten des Formulars zu versenden und empfangen. Nebenbei gibt es noch GET,
was jeder bestimmt kennt, da es sichtbar ist. (domain.de?get_variable=wert) GET sollte man für Formulare nicht
verwenden, da es sonst gewisse Sicherheitslücken hervorrufen könnte und die GET-Methode eine sehr niedrige Größe
erreichen darf.
So nun haben wir eine Abfrage erstellt, die überprüft ob der Submit-Button in der HTML-Datei angeklickt wurde oder
nicht. Jetzt schreiben wir einige eigene Funktionen, die die übergebene Werte einzeln prüfen und nach unseren
Wünschen verarbeiten. Die eigene Funktionen sind nicht unbedingt notwendig und viele Programmierer verzichten auf
diese. Was ist aber, wenn wir etwas größeres als dieses Script schreiben? Dann wird die Übersicht und die
Datenkapselung sehr schnell zur Fehlerquelle Nr. 1. Und im Falle einer erneuten Aufgabe muss der Code nicht erneut an
die Stelle geschrieben werden, es reicht, wenn man die Funktion erneut aufruft. Außerdem ist eine Funktion von außen
"geschützt". Das heißt man kann gleichnamige Variablen innerhalb einer Funktion verwenden, die im Script schon
auftauchten. Diese werden dann nicht verändert und man hat auch keinen Zugriff von außen auf diese. Ein paar
Beispiele:
PHP-Code:
<?PHP
$var = 1;
function funkt()
{ // Hier fängt ein eigener Namensbereich an
$var = 2;
echo "In der Funktion vorhandene, gleichnamige: ".$var."<BR>";
} // Hier endet dieser
echo "Außerhalb der Funktion: ".$var."<BR>"; // Gibt die außenstehende Variable $var
funkt(); /* Die Funktion wird aufgerufen und die in dieser Funktion vorhandene und gleichnamige Variable $var wird
aufgerufen */
echo "Außerhalb der Funktion: ".$var."<BR>"; // Es wird wieder die außenstehende $var aufgerufen
?>
Wie man sehen kann stören sich die zwei Variablen gleichen Namens nicht und das ist etwas was eine Funktion
auszeichnet. Wollen wir aber die $var, die außerhalb der Funktion definiert ist in einer Funktion ändern, müssen wir
$var als global kennzeichnen. Das erreicht man mit dem ebenfalls superglobalen Array $GLOBALS[]. $GLOBALS['var']
würde dann egal wo definiert, in allen Namensbereichen editier- und lesbar sein.
Aber genug Theorie, jetzt nehmen wir uns die einzelnen Felder vor und schreiben für jedes eine Funktion.
Für die ersten zwei ListBoxen brauchen wir keine Überprüfung zu machen, da man in die nichts eigenes schreiben kann,
sondern nur eine bestimmte Auswahl vorgegeben hat. Für den Vornamen und andere Felder aber sollten wir schon etwas
machen. Da Vor- und Nachname ähnliche Felder sind, schreiben wir für sie eine gemeinsame Funktion "name". Was auch
ganz wichtig ist: diese Funktionen können Sie für weitere Scripte ungeändert übernehmen und erhalten das gleiche
Ergebnis. Somit erfindet man das Rad nicht immer neu.
Um unsere Fehler, falls vorhanden sauber und übersichtlich zu empfangen, erstellen wir ein Array, was die
Fehlermeldungen enthalten soll. Dieses Array machen wir global, damit man mit unseren Funktionen darauf zugreifen
kann. Wir erstellen also:
3 Funktionen: für Vor- und Nachnamen, für die eMail-Adresse, und für den Versand von Daten an den Webmaster und den
Besucher (Bestätigungsmail).
Diese Funktionen werden wir unten definieren. Für eine Übersicht, steht folgende Skizze:
- Array für Fehlermeldungen
- Hauptabfrage Anfang
- Aufrufe von unseren 3 Funktionen und deren Verwaltung
- Hauptabfrage Ende
- Funktionendefinition
So soll das Script also aussehen. Verwirrend wirken vielleicht die Funktionen, da sie ganz am Ende stehen, wo das Script
ja von oben nach unten verläuft. Aber das ist wieder eine Sache, die Funktionen drauf haben. Es ist egal, wo im Script
sie definiert werden, wenn man die Funktion aufruft erhält man immer das gleiche Ergebnis, egal ob die Funktion oben
oder unten definiert wurde.
Und unten steht auch das fertige Script, was ich zusammengebastelt habe. Ich habe
die einzelnen Stellen so gut wie möglich kommentiert und die Funktionalität erklärt oder zu mindest es versucht.
Wichtig bei der Sache ist, dass man diesen Code nachvollziehen können sollte. Nach dem Ende des Scripts habe ich noch
die einzelnen Sachen genauer beschrieben, was vielleicht jemandem als kleine Hilfe erscheint.
(Übrigens ist das Script nicht so groß wie es aussieht, es sind nur viele Stellen mit Kommentaren drin
)
PHP-Code:
<?PHP
// Unsere PHP-Datei
// Global-Array für die Fehlermeldungen
$GLOBALS['fehler'] = array(); /* Hier wird ein Array definiert mit noch keinen Einträgen. $GLOBALS[] ist ein Array
und sagt aus, dass das Objekt in dem Index ($GLOBALS[Index eines Arrays]) überall im Script aufrufbar sein soll. Hätten
wir einfach $fehler geschrieben, würden unsere selbstgeschriebenen Funktionen nicht darauf zugreifen können.
Extra-Zeug: Wer mit C(++) etwas zutun hatte, kann es schlecht nachvollziehen, dass die globalen Objekte so gekennzeichnet
werden müssen, da es in C(++) automatisch erfolgt, soweit ein Objekt "außen" definiert wird. */
if (isset($_POST['submit'])) // Unsere Hauptanfrage
{ /* Hier fangen die Funktionsaufrufe an, um die Definition anzugucken, sehen Sie wie schon auf der Skizze gezeichnet
nach ganz unten im Script */
pruefe_name($_POST['vorname'],
"Sie haben den Vornamen nicht eingegeben.",
"Sie haben unerlaubte Zeichen im Vornamen eingegeben.");
pruefe_name($_POST['nachname'],
"Sie haben den Nachnamen nicht eingegeben.",
"Sie haben unerlaubte Zeichen im Nachnamen eingegeben.");
pruefe_email($_POST['email'],
"Sie haben keine eMail angegeben.",
"Sie haben unerlaubte Zeichen in Ihrer eMail-Adresse verwendet.");
if (empty($_POST['anfrage'])) : array_push($GLOBALS['fehler'],
"Sie haben keine Anfrage eingegeben."."<BR>"); $_POST['anfrage'] = NULL; endif; /* Hier wird überprüft
ob das Textfeld "Anfrage" keinen Wert enthällt. Falls
es so ist wird wie in unseren Funktionen auch in das Fehlermeldungs-Array geschrieben und der Wert auf NULL
umgeändert. Eine Funktion in diesem Fall zu schreiben ist nicht nötig, da hier nur zwei simple Anweisungen
erfolgen. */
/* Hier werden die Daten für den Versand eingegeben, sowie der Umgang mit Fehlermeldungen festgelegt: */
daten_senden("webmaster@domain.net",
"Anfrage - ".$_POST['thema'],
"Von: ".$_POST['anrede']." ".$_POST['vorname']." ".$_POST['nachname']."\n".
"eMail-Adresse: ".$_POST['email']."\n".
"Anfrage: \n----------\n".$_POST['anfrage'],
"Bestätigung",
"Guten Tag ".$_POST['anrede']." ".$_POST['vorname']." ".$_POST['nachname'].",\n".
"Sie erhalten diese eMail, da Sie auf unserer Webseite mit uns Kontakt aufgenommen und eine eMail-".
"Bestätigung gewünscht haben.\n".
"Ihre Anfrage wird so schnell von unseren Mitarbeitern verarbeitet und Sie werden von uns informiert.\n".
"Mit freundlichen Grüßen.",
"Leider konnte Ihre Nachricht nicht übermittelt werden.",
"Leider konnte Ihre Bestätigung nicht übermittelt werden.",
"Ihre Anfrage wurde erfolgreich gesendet.",
"Ihre Bestätigungsmail wurde erfolgreich an Sie weitergeleitet.",
"From: ".$_POST['email']." <".$_POST['vorname']." ".$_POST['nachname'].">",
"From: Mustermann");
}
// Funktionen:
function pruefe_name(&$name, $fehlermld_1, $fehlermld_2) /* &$name ist eine Referenz, das heißt es wird keine Kopie
der übergebenen Variable für die Funktion gemacht, sondern ein Aliasname erstellt, der auf die übergebene Variable
direkt zugreifen kann. Also wird nach dem Funktionsaufruf z.B. $_POST['vorname'] als Argument direkt verändert, ohne,
dass man $_POST['vorname'] = pruefe_name($_POST['vorname']); hinschreiben muss. Die anderen zwei Argumente sind dazu
da, um die zwei Fehlermeldungen zu übergeben. Die erste ist für den Fall, dass die übergebene Variable nichts
erhält und die zweite falls die Variable durch das Muster nicht passt und z.B. unerlaubte Zeichen oder Ziffern
erhält */
{
$name = trim($name); /* trim() entfernt ua. überflüssige Leerzeichen am Ende und Anfang des Strings. Danach wird
ein "sauberer" String ausgegeben und an die Variable $name übergeben */
if (empty($name)) : array_push($GLOBALS['fehler'], $fehlermld_1."<BR>");
$name = NULL; return; endif; /* Vielleicht etwas ungewöhnliche Methode eine if-Abfrage zu machen, aber manchmal
übersichtlicher, wenn es um 2-3 kleine Befehle geht: if (Bedingung) : Befehle... endif; */
/* empty() gibt true zurück, falls der String leer, undefiniert oder gleich 0 ist.
array_push() wird hier verwendet, um das Fehler-Array zu updaten. Danach wird der Wert der Variable $name evtl.
$_POST['vorname'] auf NULL gesetzt. NULL ist sowas wie unbekannt und nicht mit 0 als Zahl zu verwechseln!
Wir weisen NULL allen Feldern zu, die irgendwelche Fehler erhalten, das erleichtert die Fehlersuche im Script.
return wird verwendet, um in einer Funktion einen Rückgabewert auszugeben (return "Wert") oder die Funktion
einfach zu beenden und somit false zu liefern (return;) */
if (preg_match("/^[- A-Za-zÄÖÜßäöü]{2,25}$/i", $name))
{
return $name;
}
else
{
array_push($GLOBALS['fehler'], $fehlermld_2."<BR>");
$name = NULL;
return;
} /* Hier wird zuerst in der Funktion preg_match()
überprüft ob der String dem Muster entspricht (Argument 1) und falls ja true ausgegeben, wenn preg_match() false
zurückliefert wird auch aus unserer Funktion false kommen und die entsprechende Fehlermeldung wird im Array
gespeichert */
}
// Die nächste Funktion unterscheidet sich kaum, es wird nur ein anderes Überprüfungsmuster geschrieben
function pruefe_email(&$email, $fehlermld_1, $fehlermld_2)
{
$email = trim($email);
if (empty($email)) : array_push($GLOBALS['fehler'], $fehlermld_1."<BR>"); $email = NULL; return; endif;
if (preg_match(
"/^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$/",
$email))
/* Dieses lange Ding habe ich nicht selbst geschrieben, da für sowas wie eMails
oder URLs es genug fertige Regex im Netz gibt. Man muss ja auch nicht unbedingt zwei Stunden lang etwas in dieser
Art selbst entwickeln. (Es sei denn man lernt es gerade :)) */
{
return $email;
}
else
{
array_push($GLOBALS['fehler'], $fehlermld_2."<BR>");
$email = NULL;
return;
}
}
/* Funktion für die Versendung von Daten: (Verwaltet auch die Fehlermeldungen und Erfolgsmeldungen bei der
Benutzung der mail()-Funktion) */
function daten_senden($email, $betreff, $inhalt, $betreff_empfbest, $inhalt_empfbest, $fehlermld,
$fehlermld_empfbest, $erfolgrmld, $erfolgrmld_empfbest, $header = "", $header_empfbest = "")
/* Funktionsparameter erklärt:
$email = eMail-Adresse des Webmasters
$betreff = Betreff der Nachricht
$inhalt = Inhalt der Mail
$betreff_empfbest = Betreff der Bestätigungsmail
$inhalt_empfbest = Inhalt der Bestätigungsmail
$fehlermld = Fehlermeldung der Nachricht
$fehlermld_empfbest = Fehlermeldung der Bestätigungsmail
$erfolgrmld = Erfolgreich versendet-Meldung
$erfolgrmld_empfbest = Erfolgreich versendet-Meldung der Bestätigungsmail
$header = Header der Nachricht (optional)
$header_empfbest = Header der Bestätigungsmail (optional)
*/
{
if (sizeof($GLOBALS['fehler']) == 0) // Prüft ob das Array mit keiner Fehlermeldung gefüllt wurde
{
/* Prüfen ob die Mail an den SMTP-Server erfolgreich gesendet wird und die passende Meldung ausgeben: */
if (@mail($email, $betreff, $inhalt, $header)) { echo $erfolgrmld."<BR>"; } else { echo $fehlermld."<BR>"; }
if ($_POST['bestaetigung']) // Prüft, ob der Besucher eine eMail-Bestätigung wünscht
{
if (@mail($_POST['email'], $betreff_empfbest, $inhalt_empfbest, $header_empfbest))
{
echo $erfolgrmld_empfbest."<BR>"; // Erfolgreich gesendet-Nachricht
}
else
{
echo $fehlermld_empfbest."<BR>"; // SMTP-Fehler aufgetreten
}
}
}
else // Falls Fehler in den Feldern gefunden wurden:
{
foreach ($GLOBALS['fehler'] AS $value) // Schleife, um alle Fehler aufzuzählen, die eingetragen wurden
{
echo $value;
}
}
}
?>
Wichtige Dinge gezogen aus dem letzten PHP-Code:
- Referenzen: sind Variablen, die als Wert eine Speicheradresse einer anderen, übergebenen Variablen haben.
z.B. &$ref = $var; // weist jetzt auf den Inhalt der Variablen $var zu und arbeitet somit direkt mit dieser
$ref = 5; // Die Variable $var bekommt den Wert 5
- preg_match()-Funktion: ist eine Funktion, die mit regulären Ausdrücken nach einem Muster sucht. (Näheres im Workshop
auf TP oder/und im Manual)
- @mail(): Die Funktion mail() hat mit dem @-Zeichen nichts gmeinsam, dieses Zeichen unterdrückt bloß die Fehlermeldung,
die PHP standardweise an den Browser sendet. Das @-Zeichen kann auf viele andere Funktionen angewandt werden wie z.B.
mysql_connect().
- array_push(): Funktion, die ein Array erweitert.
- sizeof(): keine Funktion, sondern ein Operator, der die Größe eines Arrays liefert. In unserem Fall wächst das Fehler-Array
um eine Stelle, falls ein Fehler auftritt.
- foreach-Schleife: Die recht neue in PHP vorhandene foreach-Schleife durchläuft auf eine einfache Weise ein Array.
Wobei sie nicht in allen Fällen zum Einsatz kommen kann und man dann auf die guten alten for, while...-Schleifen umsteigt.
Das war es also. Bitte nicht vergessen, dass kein Mensch perfekt ist und ich nicht garantiere, dass es keine Fehler im
Script sowie im Text vorhanden sind. Ich habe für Vorschläge, Verbesserungen, Kritik und Sonstiges ein offenes Ohr und
hoffe, dass diese Arbeit einigen was bringen wird.
Im Anhang befinden sich die 2 fertigen Dateien.
MfG
![[Workshop] Formmailer](http://www.traum-projekt.com/forum/iconimages/workshops-und-tutorials/workshop-formmailer.gif){kind=small}
[Workshop] Formmailer
)
)