SELFHTML aktuell Artikel PHP
PHP:
Formularvalidierung mit regulären Ausdrücken
Stefan Eickhoff
Hinweise zum Thema
Beispiel mit Erläuterungen
Weiterführende Links
| SELFHTML aktuell Artikel PHP
| |
|
PHP:
|
|
|
| |
| E-Mail: |  self@simplecontent.net |
|---|---|
| Homepage-URL: |  http://simplecontent.net/ |
Bei Fragen zu diesem Beitrag bitte den Autor des Beitrags kontaktieren!
HTML-Formulare gehören zu den wichtigsten Interaktionsmöglichkeiten im Web. Über sie gelangen Eingaben der Nutzer via Browser zum Server und werden dort z.B. in einer Datenbank gespeichert.
Ganz gleich ob man nur Tippfehler und Nonsens-Eingaben ausschliessen, oder sich vor böswilligen Attacken schützen möchte, um eine serverseitige Überprüfung sämtlicher Daten kommt man nicht herum.
Weder mit HTML, noch mit JavaScript oder einer anderen clientseitigen Technik kann man wirklich sicherstellen, dass die Daten korrekt sind. Auch die Daten der http-header können beliebig gesetzt oder verändert werden. Daher kann man nicht feststellen ob ein Request von einem Webbrowser oder einem (manipulierten) Skript kommt.
Grundsätzlich gilt, dass allen Daten welche aus nicht vertrauenswürdigen Quellen entgegegenommen werden, zu misstrauen ist. Dazu gehören sämtliche Benutzereingaben.
Das folgende Skriptbeispiel soll den Einsatz von regulären Ausdrücken zur Eingabevalidierung demonstrieren. Kenntnisse in Regulären Ausdrücken sind also zum Verständnis des Artikels hilfreich.
Ich habe versucht das Skript auf das Nötigste zu beschränken.
Trotzdem deckt das Beispiel die wesentlichen Kriterien eines Webformulars ab. Ich hoffe, dass man es gut nachvollziehen kann.
Die wichtigsten Anforderungen die ein gutes Webformular erfüllen sollte sind:
Üblicherweise liegen alle Benutzereingaben in Form eines Arrays als "Schlüssel => Wert"-Paare vor. Das ist meist das $_POST- manchmal auch das $_GET-Array. Die Schlüssel entsprechen dabei jeweils dem "name"-Attribut des zugehörigen Formularfeldes.
Um eine größtmögliche Vertrauenswürdigkeit der Daten zu gewährleisten soll für die Formulardatenverarbeitung folgendes gelten:
^ bis Ende $ matchen.Ausserdem soll überflüssiger Leerraum (whitespace), zu Beginn und am Ende der Eingaben, immer entfernt werden.
Ebenso die u.U. automatisch ergänzten Escape-Zeichen (\ backslashes). Für die Ausgabe im Browser, und nur dort, werden alle Werte mit htmlentities() bearbeitet.
[reguläre Ausdrücke, ein paar einfache Beispiele]
'/^(|0*\d\d?|100)$/'
# gültige Eingaben sind:
# ----------------------
# leer (also kein Pflichtfeld)
# Zahl 1-100 mit beliebig vielen führenden Nullen
'/^(|[^@]+@[^@]+\.[^@]{2,})$/'
# gültige Eingaben sind:
# ----------------------
# leer (also kein Pflichtfeld)
# E-Mail-Adresse
'/^.{5,100}$/s'
# gültige Eingaben sind:
# ----------------------
# mindestens 5 aber höchstens 100 Zeichen
'/^([a-f0-9]{6})$/i'
# gültige Eingaben sind:
# ----------------------
# Farbangabe in sechsstelliger Hexadezimalschreibweise
Diese Beispiele sollen demonstrieren wie vielseitig reguläre Ausdrücke bei der Validierung von Benutzereingaben eingesetzt werden können.
Generell sollte man die Einschränkung der Eingabemöglichkeiten aber immer so gering wie möglich halten. Schnell fühlt sich der Benutzer des Formulars bevormundet wenn die Eingabevalidierung zu restriktiv ausfällt. Oft gibt es auch Ausnahmen, die man bei der Formulierung von Regeln nicht berücksichtigt hat. Da man im Web ein internationales Publikum erreicht kann man nicht immer von nationalen Gegebenheiten ausgehen. Man denke hier nur an Postleitzahlen, Datumsformate oder Tausendertrennzeichen bei Zahlen.
Auch Pflichtangaben sollten sich auf das absolut Notwendige beschränken. Hierbei sind ggf. auch Bestimmungen des Datenschutzgesetzes zu beachten. Es gilt das Gebot der "Datensparsamkeit".
Bei Intranet-Anwendungen kann man meist restriktiver bei der Einschränkung von Eingabemöglichkeiten sein. Hier werden die Dateneingabemasken auch öfter benutzt und die Benutzer stellen sich auf die Vorgaben ein.
Anzeigebeispiel: So sieht's aus
<?php
/**
* beispielformular.php
* ====================
*
* Beispiel für serverseitige Validierung von Formulardaten mit Hilfe
* von regulären Ausdrücke.
*/
ini_set('display_errors', true);
ini_set('error_reporting', E_ALL);
// ggf. Source zeigen
if (isset($_GET['showsource'])){
highlight_file(basename(__FILE__));
exit();
}
////////////////////////////////////////////////////////////
// FUNCTIONS
/**
* Callback Funktion auf "Array von Arrays"-Struktur, also ein
* verschachteltes Array anwenden.
*/
function my_array_map_recursive($callback, $arr)
{
if (!is_callable($callback)):
$debug = array_shift(debug_backtrace());
trigger_error('No valid callback function: '.$callback.'() in line '.$debug['line'], E_USER_ERROR);
endif;
if (!is_array($arr)):
$debug = array_shift(debug_backtrace());
trigger_error(__FUNCTION__.'() called in line '.$debug['line'].': Argument #2 should be an array in ', E_USER_WARNING);
$arr = array($arr);
endif;
$stack = array();
foreach ($arr as $k => $v):
if (is_array($v)):
$stack[$k] = my_array_map_recursive($callback, $v);
else:
$stack[$k] = $callback($v);
endif;
endforeach;
return $stack;
}
/**
* preg_match() auf "Array von Arrays"-Struktur, also ein
* verschachteltes Array anwenden.
*/
function my_preg_match_recursive($regexp, $s)
{
$success = false;
if (!is_array($s)):
$success = preg_match($regexp, $s);
if ($success === false):
$debug = array_shift(debug_backtrace());
trigger_error('No valid regular expression: '.htmlentities($regexp).'() in line '.$debug['line'], E_USER_ERROR);
endif;
else:
foreach ($s as $a):
$success = my_preg_match_recursive($regexp, $a);
if (!$success):
return false;
endif;
endforeach;
endif;
return $success;
}
Üblicherweise liegen die Formulardaten im $_POST-Array vor. (Ich beziehe mich hier immer auf das $_POST-Array, für $_GET u.ä. gilt entsprechendes.) Dabei sind "Array von Array"-Strukturen - also verschachtelte Arrays - eher die Regel, denn die Ausnahme. Man denke nur an Checkboxen oder Mehrfachauswahllisten.
An einigen Stellen im Skript müssen wir sämtliche Array-Elemente abarbeiten, also rekursiv vorgehen. Da im Funktionsumfang von PHP nichts passendes zur Verfügung steht kommen hier die folgenden User-Funktionen zum Einsatz.
Die Funktion my_array_map_recursive() wendet eine Callback-Funktion, und my_preg_match_recursive() die PHP-Funktion preg_match() auf alle Array-Elemente an.
Mit Hilfe von debug_backtrace() wird hier im Falle eines Fehlers die Zeile des Funktionsaufrufs ermittelt um die Fehlersuche zu erleichtern.
/**
* Werte des Eingangs-Array ($data_in) anhand von RegExp-Regeln ($rules)
* prüfen, sofern das Formular gesendet wurde ($trigger is true).
* Oder Standardwerte ($defaults) zurückgeben ($trigger is false).
*
* Parameter der Funktion:
*
* $defaults (array)
* 'Name des Formfeldes' => 'Standardwert/ Vorbelegung'
*
* $rules (array)
* 'Name des Formfeldes' => (array)
* 'RegExp' => 'Text der Fehlermeldung'
*
* $data_in (array)
* zu prüfende Daten, i.d.R. $_POST oder $_GET
*
* $trigger (bool)
* Formular gesendet (true)
* oder erstmaliger Aufruf mit Standardbelegung (false)
*
*
* Rückgabe erfolgt als assoziatives Array:
*
* values => mit trim und stripslashes bearbeitete Werte
* des Eingangs-Arrays.
* messages => ggf. die Fehlermeldung je Formularfeld
* errors => Gesamtfehlerzahl
*/
function apply_rules($defaults, $rules, $data_in, $trigger)
{
# Template für Fehlermeldungen
$msg_tpl = '<p class="errormessage">%s</p>';
$data_out = array();
$messages = array();
$errors = 0;
// Es werden nur Werte bearbeitet die im Array $default
// enthalten sind!
$keys = array_keys($defaults);
foreach ($keys as $k):
// Fehlermeldung initialisieren
$messages[$k] = false;
// Wenn Schlüssel nicht im Array $data_in enthalten Standardwert zuweisen.
if (!isset($data_in[$k])):
$data_out[$k] = $defaults[$k];
continue;
endif;
// Es sollen _alle_ Eingaben validiert werden.
// Wenn keine Validierungsregel angegeben ist wird ein Fehler erzeugt.
// Es wird dann die Standardbelegung aus dem Array $default zugewiesen.
if (!isset($rules[$k])):
$data_out[$k] = $defaults[$k];
trigger_error('Keine Validierungsregel für '.$k.' definiert. ', E_USER_NOTICE);
continue;
endif;
// Wert im Ausgangs-Array ablegen
$data_out[$k] = $data_in[$k];
endforeach;
// Whitespace am Anfang und am Ende entfernen
$data_out = my_array_map_recursive('trim', $data_out);
// automatisch ergänzte Slashes entfernen
if (get_magic_quotes_gpc()){
$data_out = my_array_map_recursive('stripslashes', $data_out);
}
// Wenn das Formular nicht abgeschickt wurde sollen auch keine
// Validierungen vorgenommen werden.
// Dazu wird hier ggf. das Array mit den Validierungsregeln geleert.
// Dies sorgt dafür dass die folgende foreach-Schleife zur Validierung
// _nicht_ durchlaufen wird.
if ($trigger == false):
$keys = array();
endif;
// Die Validierungsregeln je Schlüssel abarbeiten
foreach ($keys as $k):
$v = $rules[$k];
while (list($rule, $msg) = each($v)):
$success = my_preg_match_recursive($rule, $data_out[$k]);
// Falls die Validierung fehlschlägt die zugehörige
// Fehlermeldung im Meldungs-Array ablegen und die
// Gesamtfehlerzahl erhöhen.
if (!$success){
$messages[$k] = sprintf($msg_tpl, $msg);
$errors ++;
break;
}
endwhile;
endforeach;
$result = array(
'values' => $data_out,
'messages' => $messages,
'errors' => $errors,
);
return $result;
}
Die Funktion apply_rules() leistet hier die eigentliche Arbeit bei der Validierung.
Hier werden alle Elemente des übergebenen Arrays $data_in anhand der im Array $rules definierten Regeln geprüft. Es wird je Schlüssel immer nur bis zum ersten Auftreten eines Fehlers geprüft. Man kann also beliebig viele reguläre Ausdrücke zur Prüfung festlegen. Es wird dann nur die zugehörige Fehlermeldung des ersten Ausdrucks der fehlschlägt im Array der Meldungen vermerkt.
Die Rückgabe erfolgt als Array welches nur Werte enthält die alle definierten Tests passiert haben. Ein weiteres Array enthält alle Fehlermeldungen und schliesslich noch die Gesamtzahl der aufgetretenen Fehler.
Gegebenenfalls werden als Formularwerte auch die im Array $defaults übergebenen Standardwerte zugewiesen, z.B. wenn das Formular erstmalig aufgerufen wird, also noch nicht abgeschickt wurde.
An der Vielzahl und komplexen Struktur der Übergabe- und Rückgabeparameter sieht man deutlich, dass hier eher ein objektorientierter Lösungsansatz angemessen wäre. Das würde aber den Rahmen dieses kleinen Artikels sprengen.
function get_form()
{
// Vorbelegung aller Formularfelder
$defaults = array
(
'sender' => '',
'email' => '',
'comment' => '',
'date' => '',
'cb' => '',
'number' => array('', ''),
);
// Die Validierungsregeln werden in einer Array von Arrays Struktur abgelegt.
// Der Aufbau des Arrays ist dabei wie folgt:
//
// $rules = array();
// $rules['NameFormularFeld1'] = array ('RegExp1' => 'Fehlermeldung 1', 'RegExp2' => 'Fehlermeldung 2');
// $rules['NameFormularFeld2'] = array ('RegExp3' => 'Fehlermeldung 3');
// etc.
//
// Jedem Formularfeld können beliebig viele Validierungsregeln zugeordnet werden.
// Jede Regel entspricht einem "Schlüssel => Wert"-Paar, wobei als Schlüssel
// der reguläre Ausdruck und als Wert die gewünschte Fehlermeldung dient.
// Häufiger genutzte Regeln:
# Pflichtangabe
$rule_required = '#^.+$#s';
# gültiges Datum, aber keine Schaltjahrüberprüfung! [1] Erläuterung, siehe Text.
$rule_date = '/^((0?\d|[1-2]\d)[. -]\s*(0?[1-9]|10|11|12)|(30)[. -]
\s*(0?[13456789]|10|11|12)|(31)[. -]\s*(0?[13578]|10|12))[. -]\s*(19\d\d|20\d\d)$/x';
// Regeln je Eingabefeld zuweisen ...
$rules = array();
$rules['date'] = array(
$rule_required => 'Die Angabe eines Datums ist Pflicht',
'#^[0-9. -]*$#' => 'Erlaubte Zeichen sind 0-9 . und -',
'#^\d\d?[. -]\s*\d\d?[. -]\s*\d{4}$#' => 'Das Datumsformat ist ungültig. Bitte im Format dd.mm.yyyy eingeben',
'#(19\d\d|20\d\d)$#' => 'Bitte ein Jahr zwischen 1900 und 2099 wählen',
$rule_date => 'Diesen Tag gibt es nicht im Kalender',
);
$rules['cb'] = array(
'#^(|on)$#' => 'Na sowas? Da hat die Checkbox plötzlich ganz andere Werte als vorgegeben.',
);
$rules['number'] = array(
'#^[0-9]*$#' => 'Hier sind nur Zahlen (0-9) möglich',
'#^(|0*\d\d?|100)$#' => 'Bitte nur Zahlen von 1-100. Danke',
);
$rules['comment'] = array(
$rule_required => 'Die Angabe eines Kommentars ist Pflicht',
'#^.{5,}$#m' => 'Mehr hast Du nicht zu sagen?',
'#^.{1,100}$#s' => 'Der Kommentar sollte nicht länger als 100 Zeichen sein.',
);
$rules['sender'] = array(
$rule_required => 'Die Angabe eines Namens ist Pflicht',
'#^.{0,30}$#' => 'Der Name darf maximal 30 Zeichen lang sein.',
'#^.{3,}$#' => 'Der Name sollte länger als 2 Zeichen lang sein.',
'#^\D*$#' => 'Der Name soll keine Zahlen enthalten.',
);
$rules['email'] = array
(
'#^([^@]+@[^@]+\.[^@]{2,}|)$#' => 'Bitte korrigieren Sie die E-Mail-Adresse oder lassen Sie dieses Feld frei.',
);
// Formular schon abgeschickt?
$form_send = (isset($_POST['PREVIEWBUTTON']) || isset($_POST['SUBMITBUTTON']) );
$trusted_data = apply_rules ($defaults, $rules, &$_POST, $form_send);
$messages = $trusted_data['messages'];
$values = $trusted_data['values'];
$errors = $trusted_data['errors'];
// htmlentities() anwenden
$values = my_array_map_recursive('htmlentities', $values);
// wenn erfolgreich validiert, also ohne Fehlermeldung, hier einen
// zusätzlichen Submit-Button zum "richtigen" Absenden ergänzen.
// Sonst gibt es nur einen Vorschau-Button.
$submit = ($errors == 0) && ($form_send)
? '<input type="submit" name="SUBMITBUTTON" value="Eintragen" />'
: '';
// Ergebnis der Validierung ($ok) "Mit Fehlern" bzw. "Ohne Fehler".
if ($errors == 0){
$ok = true;
}else{
$ok = false;
}
// Eine Liste aller Fehlermeldungen erstellen
$errorlist = '';
if ($form_send):
$errorlist = $errors == 0
? '<h2>Vorschau, die Daten wurden noch nicht gespeichert!</h2>
<p>Sie haben alle erforderlichen Daten eingegeben.
Das Formular kann jetzt abgeschickt werden.</p>'
: '<h2>Einige Formulareingaben sind unvollständig oder
fehlerhaft</h2><ul><li>'.
join('</li><li>', array_filter($messages)).
'</li></ul>';
endif;
// Checkboxen selektiert?
$is_checked = array('', '', '', '');
if (isset($_POST['cb'])):
foreach (array_keys($_POST['cb']) as $k){
$is_checked[$k] = ' checked="checked"';
}
endif;
// Das Formular
$form = <<< EOT
$errorlist
<form action="{$_SERVER['REQUEST_URI']}#form" method="post">
<fieldset>
<legend>Beispielformular</legend>
<label class="blockelement">Name <span class="required">*</span></label>
{$messages['sender']}
<input type="text" name="sender" value="{$values['sender']}"/>
<label class="blockelement">Email</label>
{$messages['email']}
<input type="text" name="email" value="{$values['email']}"/>
<label class="blockelement">Kommentar <span class="required">*</span></label>
{$messages['comment']}
<textarea name="comment" rows="2" cols="40">{$values['comment']}</textarea>
<fieldset>
<legend>Bitte aus Optionen A-D auswählen</legend>
{$messages['cb']}
<label>A</label>
<input type="checkbox" name="cb[0]" value="on"{$is_checked[0]} />
<label>B</label>
<input type="checkbox" name="cb[1]" value="'#;"{$is_checked[1]} />
<label>C</label>
<input type="checkbox" name="cb[2]" value="on"{$is_checked[2]} />
<label>D</label>
<input type="checkbox" name="cb[3]" value="on"{$is_checked[3]} />
</fieldset>
<fieldset>
<legend>Nenne zwei Zahlen zwischen 1 und 100</legend>
{$messages['number']}
<input type="text" name="number[0]" value="{$values['number'][0]}" />
<input type="text" name="number[1]" value="{$values['number'][1]}" />
</fieldset>
<label class="blockelement">Datum (dd.mm.yyyy) <span class="required">*</span></label>
{$messages['date']}
<input type="text" name="date" value="{$values['date']}" class="blockelement" />
<input type="submit" name="PREVIEWBUTTON" value="Vorschau" />
$submit
</fieldset>
</form>
<p><strong>Hinweis</strong> Alle mit <span class="required">*</span>
markierte Felder sind Pflichtangaben.</p>
<p><strong>Hinweis</strong> Die Checkbox <em>B</em> ist hier absichtlich mit einem
Wert versehen worden der bei der Validierung durchfällt.
Das dient hier nur der Demonstration.
</p>
EOT;
$result = array
(
'form' => $form,
'data' => $trusted_data['values'],
'ok' => $ok,
);
return $result;
}
// END FUNCTIONS
////////////////////////////////////////////////////////////
In der User-Funktion get_form() werden die Standardbelegungen und die Validierungsregeln, sowie das Formular selbst festgelegt.
Hier noch ein Beispiel für einen etwas komplexeren regulären Ausdruck [1]. Er soll ein eingegebenes Datum auf Korrektheit prüfen.
Das funktioniert sogar, allerdings nur fast. Beachten Sie den Hinweis am Ende dieses Artikels.
Im vorangegangenen Abschnitt war dieser RegExp als Einzeiler ausgeführt. Deshalb hier nochmal in etwas besser lesbarer Form.
$rule_date = '/ # passt auf ... ^( (0?\d|[1-2]\d) # 01-09 und 1-29 [. -]\s* # Delimiter, optionaler Whitespace (0?[1-9]|10|11|12) # 01-09 und 1-12 | # ODER (30) # 30 [. -]\s* # Delimiter, optionaler Whitespace (0?[13456789]|10|11|12)# 1-12 oder 01-09, aber nicht 02 und 2! | # ODER (31) # 31 [. -]\s* # Delimiter, optionaler Whitespace (0?[13578]|10|12) # 1,01,3,03,5,05,7,05,8,08,10 oder 12 ) [. -]\s* # Delimiter, optionaler Whitespace (19\d\d|20\d\d) # 1900-2099 $/x';
////////////////////////////////////////////////////////////
// MAIN
session_start();
$theContent = '';
// Je nach Aktion des Benutzers unterschiedliche Ansichten ausliefern.
$ACTION = isset($_REQUEST['ACTION'])
? $_REQUEST['ACTION']
: 'START';
switch ($ACTION):
case 'DONE':
# [2] Anmerkung, siehe Text.
$theContent = <<< EOT
<h2>Vielen Dank für Ihren Beitrag.</h2>
<dl>
EOT;
ob_start();
print_r($_SESSION['FORMDATA']);
$tmp = ob_get_contents();
ob_end_clean();
$theContent .= '<pre>'.$tmp.'</pre>';
break;
case 'START':
// "fall through" beabsichtigt
default:
$isok = false;
$arr = get_form();
$isok = $arr['ok'];
if (isset($_POST['SUBMITBUTTON']) && $isok):
# [3] Anmerkung, siehe Text.
// in Datei bzw. Datenbank schreiben, oder was auch immer
// man sonst mit den Daten tun möchte
// [...]
# [4] Anmerkung, siehe Text.
// Weiterleitung zur "Danke"-Seite.
$_SESSION['FORMDATA'] = $arr['data'];
$url2go = 'http://'.$_SERVER['HTTP_HOST'].$_SERVER['PHP_SELF'].'?ACTION=DONE&'.SID;
header('Location: '.$url2go);
exit();
else:
// Das Formular soll (erstmalig | erneut) gezeigt werden
$theContent = $arr['form'];
endif;
break;
endswitch;
// END: MAIN
////////////////////////////////////////////////////////////
Hier wird der eigentliche Programmablauf über eine switch-Anweisung gesteuert.
Es gibt nur zwei Ansichten, zum einen das Formular und zum anderen eine Bestätigungsseite, welche nach erfolgreichem Formularversand angezeigt wird.
Auf einer solchen "Danke"-Seite sollten die Benutzereingaben noch einmal aufgeführt werden.
Das könnte man erreichen indem man im Abschnitt der Datenverarbeitung bzw. Weiterleitung (redirect) [4] die ID des neuen Eintrages per URL oder Session übermittelt.
Auf der "Danke"-Seite [2] wird die Ausgabe um eine Anzeige des Datensatzes mit dieser ID ergänzt.
Im Beispielskript werden der Einfachheit halber die Daten über eine Session weitergereicht.
Wichtiger Hinweis: Fast immer ergänzt PHP automatisch Backslashes (magic_quotes_gpc = On) um potentiell schädliche Einträge zu entschärfen. Diese automatischen Backslashes haben wir in der Funktion apply_rules() entfernt. Sollen die Daten jetzt an [3] weiterverarbeitet werden, muss man selbst für ein richtiges Escapen sorgen. Für MySQL-Queries bietet sich die Funktion mysql_real_escape_string() an.
Anzeigebeispiel: Der komplette Sourcecode
////////////////////////////////////////////////////////////
// OUTPUT
echo <<< EOT
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Formularvalidierung mit regulären Ausdrücken</title>
<style type ="text/css">
span.required {color:#00cc00;font-size:0.8em;}
fieldset {background-color:#e1e1e1;width:300px;padding:2px;}
dt {font-weight:bold;}
.blockelement {display:block;}
p.errormessage {color:#cc0000;margin:0px;}
</style>
</head>
<body>
$theContent
</body>
</html>
EOT;
// END: OUTPUT
////////////////////////////////////////////////////////////
?>
Am Ende des Skriptes erfolgt die Ausgabe der HTML-Seite. Hier wird lediglich die Variable $theContent im "here doc"-Abschnitt ersetzt.
Wichtig bei der Formulierung von regulären Ausdrücken zur Validierung ist, dass jeder Ausdruck den gesamten String vom Anfang ^ bis zum Ende $ prüft. Auch wenn man nahezu jede Eingabevalidierung abbilden kann gibt es Einschränkungen, die sich nur durch den Einsatz weiterer Funktionen aufheben lassen. Als Beispiel sei hier auf die Überprüfung des Datums verwiesen. Hier ist die Eingabe des 29. Februar für jedes Jahr möglich, es wird also nicht auf ein gültiges Schaltjahr geprüft. Das müssen dann zusätzliche Funktionen wie z.B. maketime() übernehmen.
Ob und welche Validierungen notwendig sind hängt von der Art der Weiterverarbeitung ab. Je nach Verwendung der Formulardaten kann es durchaus ausreichend sein lediglich Anführungen mit Backslashes zu maskieren, beispielsweise um diese Daten als E-Mail-Text zu versenden. Sollen Benutzereingaben später auf der eigenen Website angezeigt werden, also in Gästebüchern und Foren etc. sollte man:
strip_tags() und/oder durch htmlentities() entschärfeninclude() einbinden, da dann enthaltener Skriptcode ausgeführt wirdfile_get_contents() & Co einbindeneval() verzichtenAbschliessend seien noch einige Fehler genannt, die bei der Formularverarbeitung gerne gemacht werden:
htmlentities(), addslashes())
Die folgenden Stellen werden empfohlen, um das obige Beispiel besser zu verstehen, oder um weitere Möglichkeiten und Details zu erfahren.
SELFHTML: Formulare
PHP: $_POST
PHP: Pattern Syntax
RegExp: Regular Expression Library
RegExp: tool for testing regular expressions online
Perl: Perl regular expressions
© 2007 Impressum, für diese Seite: self@simplecontent.net