Kaum ein Formular in den Tiefen des www kümmert sich wirklich ernstzunehmend um die Hausnummer. Für mich recht erstaunlich, da z. B. für eine reibungsarme Abwicklung des immer breiter werdenden Internethandels diese in der Lieferadresse doch keine so unwesentliche Rolle spielt. Fehllieferungen aufgrund falscher Adressdaten sind ein nicht zu unterschätzender wirtschaftlicher Faktor. Durch den Segen von HTML5 gibt es nun ohne viel Aufwand die Möglichkeit, Benutzereingaben durch die RegEx-Pattern live vorab zu prüfen. Bei meinen Recherchen für ein gut aufgestelltes Formular habe ich viele nützliche Pattern gefunden, aber kein einziges, welches nur annährend sinnvoll eine Hausnummer geprüft hätte. Also: Selbst ist der Progger.
Als erstes galt meine Recherche grundsätzlich der Form von deutschen Hausnummern. Alles zutiefst Bürokratische mag sich der geneigte Leser selbst auf einschlägigen Webseiten erlesen. Die Form ist recht eindeutig (Zahl)[[(Buchstabe)][(-)][[(Buchstabe)oder(Zahl)][(Buchstabe)]]]. Nicht eindeutig? Hm. Dann in Worte verpackt: Eine gute deutsche Hausnummer muss mindestens aus einer Zahl (und da aus mindestens einer Ziffer außer 0) bestehen. Diese Zahl kann dann ohne Leerraum von einem Buchstaben des Alphabets (ohne Umlaute und ß) begleitet werden. Soweit recht nachvollziehbar (Bsp. 23a). Muss also nur noch ermittelt werden, was die höchste Hausnummer z. Z. in Deutschland ist. Dazu bot mir die google-Suche diesen interessanten Artikel der FAZ an:
Deutschlands höchste Hausnummer. Wir stehen also bei 1503 als Spitzenwert, d. h. mit ein wenig Perspektive sollte die Zahl 5stellig sein. Mal abgesehen davon, dass es recht sinnbildlich ist, dass die Bewohnerin der Venloer Straße 1503 in Köln Frau Höchstens heißt, blicken wir gleich noch auf eine vorherige Hausnummer dieser offenbar endlos langen Straße, die 1226-1228 der Kirche „St. Johannes vor dem Lateinischen Tore“ (was für ein Paradebeispiel für eine komplizierte Adresse). So haben wir einen weiteren Parameter: Die gesamte Hausnummer kann also aus zwei 4stelligen Zahlen mit einem Bindestrich dazwischen bestehen, also schonmal 9stellig. Doch halt, da sind ja noch die dazwischen gebauten Gebäude mit den Buchstaben. Ich habe bisher zwar kein Beispiel für so ein Konstrukt gefunden, aber möglich ist es wohl (Bsp. 1130a-1132c). Damit steigt das Stellenlimit auf 11. Rechnen wir noch die Reserve rein (man hat ja gesehen, wie das z. B. bei IPv4 so gelaufen ist...), dann brauchen wir ein Muster, welches maximal 13 Zeichen aus Zahlen, Buchstaben und dem Bindestrich haben kann. Damit ist der grobe Rahmen schon mal abgesteckt und mit einem schlichten [maxlength="13"] im HTML-Code leicht zu setzen. Danach fängt der Schlamassel an (ein Lesetipp an dieser Stelle:
input PATTERN):
Mindestens eine Ziffer außer Null. Ok.
CODE:
([1-9])
Gefolgt von keiner oder maximal 4 Ziffern oder einem Buchstaben oder x Ziffern und einem Buchstaben. Na gut. Die grobe Spanne ist also NULL - 9999z (höchste mögliche Hausnummer wäre dann die 99999z).
CODE:
([0-9]{0,4}[a-z]?|[a-z]?)
Soweit, so gut. Nun kommen aber die üblen übergreifenden Hausnummern mit dem noch übleren Bindestrich. Und der darf dann auch nur höchstens einmal vorkommen. Versuchen wir es.
CODE:
(-?)
Sieht doch eher simpel aus. Nun müssen wir das Spiel ja nach dem Bindestrich eigentlich nur wiederholen (mit einer Stelle zusätzlich wegen der gesetzten Anfangsziffer) und wir wären glücklich.
CODE:
([0-9]{0,5}[a-z]?|[a-z]?)
Das bis dahin zusammengebastelte Muster wären dann:
CODE:
pattern="([1-9])([0-9]{0,4}[a-z]?|[a-z]?)(-?)([0-9]{0,5}[a-z]?|[a-z]?)"
Ein paar Tests zeigen schnell, dass das nicht der Weisheit letzter Schluss sein kann. So sind z. B. die Eingaben 11-092 oder 23aaa möglich. Wenn die Stellen 2-5 aus Buchstaben oder Ziffern bestehen (die Stelle 6 kann nur ein Buchstabe sein), wäre es also möglich, dass ohne den Bindestrich dahinter ein weiterer Buchstabe folgen könnte. Das geht so nicht. Beides lässt sich durch negative Vorausschau vor und nach dem möglichen Bindestrich verhindern:
CODE:
(?![a-z])(-?)(?!0)
Damit wäre das Muster eigentlich komplett:
CODE:
pattern="([1-9])([0-9]{0,4}[a-z]?|[a-z]?)(?![a-z])(-?)(?!0)([0-9]{0,5}[a-z]?|[a-z]?)"
Aber... Testet mal selbst. Abgesehen von der Möglichkeit, z. B. 11f-9b eingeben zu können, was durch die beschränkten Wenn-dann-Bedingungen der RegEx nicht auszumerzen geht und durch einen weiterführenden Prüfalgorithmus (z. B. mit PHP, siehe unten) geleistet werden muss, gibt es noch weitere ungültige Eingabemöglichkeiten, z. B. 1a1. Also müssen wir das Pattern an der ersten Stelle der negativen Voraussage noch um den Ziffernbereich erweitern. Dann sollte es endlich passen:
CODE:
pattern="([1-9])([0-9]{0,4}[a-z]?|[a-z]?)(?![a-z0-9])(-?)(?!0)([0-9]{0,5}[a-z]?|[a-z]?)"
Jetzt wird der Benutzer des Formulars zumindest dazu genötigt, die Hausnummer strukturell richtig eingeben zu müssen. Das war die erste Hälfte der Arbeit. Jetzt kommt die logische Prüfung.
Meine Verarbeitung von Web-Formularen übernimmt PHP 7.x. Um diese Prüfung allen Formularen eines Web-Projektes bequem zur Verfügung zu stellen, habe ich mich entschieden, eine Klasse "FormularPruefen" zu implementieren. Diese könnte in etwa wie folgt aussehen:
CODE:
<?php
##### Funktionssammlung für allgemeine Formularprüfungen #####
class FormularPruefen {
public $hnr;
public $tel1;
public $tel2;
public $fehler = 0;
public $fehler_hinweis = 'Bitte korrigieren: ';
/**
<strong> logische Prüfung der eingegebenen Hausnummer {(Zahl1)[(Buchstabe1)][[-]][[Zahl2]][(Buchstabe2)]}
</strong>
<strong> @param string $this->hnr, int $this->fehler, string $this->fehler_hinweis
</strong>
<strong> @return string $this->hnr
</strong>/
function formularPruefenHnr() {
$arr = explode('-', $this->hnr);
//wenn nur ein Array-Eintrag (kein '-') muss nichts geprüft werden
if (count($arr) === 2){
//wenn nach dem '-' nichts eingegeben wurde -> entferne '-'
if ($arr[1] === ''){
$this->hnr = str_replace('-', '', $this->hnr);
//wenn beide Blöcke der Hausnummer gleich sind (11-11 oder 11a-11a)
}else if ($arr[0] == $arr[1]){
$this->fehler++;
$this->fehler_hinweis .= "Erste und zweite Zahl der Hausnummer dürfen nicht identisch sein. ";
//wenn beides Zahlen sind (Bsp: 8-11)
}else if (is_numeric($arr[0]) && is_numeric($arr[1]) && $arr[0] > $arr[1]){
$this->fehler++;
$this->fehler_hinweis .= "Erste Zahl der Hausnummer darf nicht größer sein als die zweite. ";
//wenn erster Block Zahl, zweiter Block nicht (Bsp: 8-10b)
}else if (is_numeric($arr[0]) && !is_numeric($arr[1])){
$arr1 = str_split($arr[1]);
array_pop($arr1);
$zahl2 = '';
foreach ($arr1 as $v){
$zahl2 .= $v;
}
if ($arr[0] > $zahl2){
$this->fehler++;
$this->fehler_hinweis .= "Erste Zahl der Hausnummer darf nicht größer sein als die zweite. ";
}
//wenn erster Block keine Zahl, zweiter Block ja (Bsp: 8b-10 aber nicht 1a-1, nur 1-1a)
}else if (!is_numeric($arr[0]) && is_numeric($arr[1])){
$arr0 = str_split($arr[0]);
array_pop($arr0);
$zahl1 = '';
foreach ($arr0 as $v){
$zahl1 .= $v;
}
if ($zahl1 >= $arr[1]){
$this->fehler++;
$this->fehler_hinweis .= "Erste Zahl der Hausnummer (gefolgt von einem Buchstaben) darf nicht gleich oder größer sein als die zweite. ";
}
//wenn beide Blöcke keine Zahlen sind (10a-11a oder 10a-f)
}else if (!is_numeric($arr[0]) && !is_numeric($arr[1])){
$arr0 = str_split($arr[0]);
$arr1 = str_split($arr[1]);
//wenn zweiter Block Zahl und Buchstabe (10a-11a)
if (count($arr1) > 1){
$char0 = array_pop($arr0);
$char1 = array_pop($arr1);
$zahl1 = '';
$zahl2 = '';
foreach ($arr0 as $v){
$zahl1 .= $v;
}
foreach ($arr1 as $v){
$zahl2 .= $v;
}
if ($zahl1 > $zahl2){
$this->fehler++;
$this->fehler_hinweis .= "Erste Zahl der Hausnummer darf nicht größer sein als die zweite. ";
}else if ($zahl1 == $zahl2 && $char0 >= $char1){
$this->fehler++;
$this->fehler_hinweis .= "Bei gleicher Hausnummerzahl darf erster Buchstabe im Alphabet nicht hinter dem zweiten stehen. ";
}
//wenn zweiter Block nur Buchstabe (10a-f)
}else {
$char1 = array_pop($arr0);
if ($char1[0] > $arr1[0]){
$this->fehler++;
$this->fehler_hinweis .= "Erster Buchstabe der Hausnummer darf im Alphabet nicht hinter dem zweiten sein. ";
}
}
}
}
return $this->hnr;
}
/**
<strong> logische Prüfung der Telefonnummerneingabe
</strong>
<strong> @param string $this->tel1, string $this->tel2, int $this->fehler, string $this->fehler_hinweis
</strong>
<strong> @return void
</strong>/
function formularPruefenTel() {
if ($this->tel1 === $this->tel2){
$this->fehler++;
$this->fehler_hinweis .= "Telefon 1 und Telefon 2 müssen unterschiedlich sein. ";
}
}
//weitere Funktionen...
}
?>
Nach Instanzieren des Objekts (idealerweise wird die Klasse über einen autoloader geladen) durch
CODE:
$pruefen = new FormularPruefen();
der Werteübergabe
CODE:
$pruefen->hnr = $_POST['hnr']
->tel1 = $_POST['tel1']
->tel2 = $_POST['tel2'];
und Ausführen der Funktionen (da ja bei der Eingabe die Möglichkeit besteht, dass der Bindestrich ohne gefolgten Wert eingegeben werden kann, wird dieser bei Prüfung entfernt -> Funktion gibt also die bereinigte Hausnummer zurück)
CODE:
$hnr = $pruefen->formularPruefenHnr();
und
CODE:
$pruefen->formularPruefenTel();
kann über
CODE:
if ($pruefen->fehler > 0){
echo $pruefen->fehler_hinweis;
}
die Fehlerausgabe erfolgen. Die einzelnen Teile der Funktionen sollten durch die Kommentare hinreichend verständlich sein.
Ich hätte, als ich begann, mich mit dem Prüfen von Hausnummern in einem Webformular zu beschäftigen, nie gedacht, dass man dieses Thema glatt zu einer Projektarbeit ausweiten könnte. Wer für diese Geschichte eine effizientere und/oder elegantere Lösung parat hat, der möge sie bitte in einem Kommentar kundtun.
Zutaten:
