[ Input Pattern ]

Formularfelder validieren

Input Pattern Beispiele

Datum und Zeit

Tage, Monate, Jahre

Tage Format: 01-31; 1-31
pattern="0?[1-9]|[0-2]\d|3[01]"
Wochentag Format: Wochentag
pattern="(Mon|Diens|Donners|Frei|Sams|Sonn)tag|Mittwoch"
pattern="M[oi]|D[io]|Fr|S[ao]"
pattern="Mon|Tues?|Wed|Thurs?|Fri|S(at|un)"
Monat Format: 01-12; 1-12
pattern="0?[1-9]|1[0-2]"
Monate geschrieben Format: Monat, Month
pattern="(Jan|Feb|Mrz|Apr|Mai|Ju[nl]|Aug|Sep|Okt|Nov|Dez"
pattern="(Janu|Febru)ar|März|April|Mai|Ju(ni|li)|August|(Septem|Okto|Novem|Dezem)ber"
pattern="(Janu|Febru)ary|March|April|May|Ju(ne|ly)|August|(Septem|Octo|Novem|Decem)ber"
pattern="(Janv|Fév)ier|Mars|Avril|Mai|Jui(n|llet)|Août|(Septem|Octo|Novem|Décem)bre"
pattern="(ene|febre)ro|marzo|abril|mayo|ju(nio|lio)|agosto|(septiem|octu|noviem|diciem)bre"
Jahr Format: JJ, JJJJ kein Jahr "0000"
pattern="\d{2}|(?!0000)\d{4}"

Datum

Datum einfach D Format: TT.MM.JJJJ
pattern="(0[1-9]|[12]\d|3[01])\.(0\d|1[0-2])\.[12]\d{3}"

01.01.1900
31.12.2999
1.1.1900
31.12.99

Datum einfach engl. Format: YYYY-MM-DD
pattern="[12]\d{3}-(0\d|1[0-2])-(0[1-9]|[12]\d|3[01])"

Datum einfach AM Format: MM/DD/YYYY
pattern="(0\d|1[0-2])/(0[1-9]|[12]\d|3[01])/[12]\d{3}"

Datum (Middle-Endian-Reihenfolge des US-Formats) Format: Month DD, YYYY
pattern="((Janu|Febru)ary|March|April|May|Ju(ne|ly)|August|(Septem|Octo|Novem|Decem)ber) [0-2]\d, [12]\d{3}"

March 5, 1956 x


Schaltjahr

Ein Schaltjahr

Ein Jahr hat die Länge von 365 Tagen, 5 Stunden, 48 Minuten und 47 Sekunden. Da dies etwas unpraktisch ist, hat man dem normalen Jahr eine Länge von 365 Tage gegeben. Zum Ausgleich schiebt man alle 4 Jahre einen Tag - den 29. Februar - ein. Nach gregorianischem Kalender tut man dies seit 1582 (in D erst ab 1700) jedoch alle 100 Jahre nicht, dann aber alle 400 Jahre doch. Davor war der julianische Kalender gültig der hatte alle 4 Jahre ein Schaltjahr. Kann man dafür Muster bauen? Yes we can!

Ich war fleisig und habe mal alle Schaltjahre für die Jahre 0000 - 9999 in ein Muster gepackt: Zuerst die 100ter-Jahre die Schaltjahr sind und die 400ter die doch Schaltjahre sind.(([02468][048]|[13579][26])00). Dann die 4-Jahresschritte.(\d{2}(0[48]|[13579][26]|[2468][048])) Das Jahr 0 gab es nie. Ich nutze die negative Voraussage. (Eingabe ist "nicht x") (?!x). (?!0000). Das ist für das nicht-Schaltjahresmuster ebenfalls gut zu gebrauchen.

Alle julianischen Schaltjahre 0001-1582 Format: JJJJ
pattern="(?!0000)(0\d([13579][26]|[02468][048]))|1[1-4]([13579][26]|[02468][048])|15([1357][26]|[0246][048]|80)"

Alle gregorianischen Schaltjahre simple 0001-9999 Format: JJJJ
pattern="(?!0000)(([02468][048]|[13579][26])00)|(\d{2}(0[48]|[13579][26]|[2468][048]))"

Alle gregorianischen Nicht-Schaltjahre simple 0001-9999 Format: JJJJ
pattern="(?!(([02468][048]|[13579][26])00)|(\d{2}(0[48]|[13579][26]|[2468][048])))\d{4}"

Alle gregorianischen Schaltjahre 1584-9999 Format: JJJJ
pattern="(([2468][48]|[13579][26])00)|([1-9][6-9](0[48]|[13579][26]|[2468][048])|158[48]|159[26])"

Alle Schaltjahre julianisch/gregoreanisch korrekt: 0001-9999 Format: JJJJ
pattern="(?!0000)(0\d([13579][26]|[02468][048]))|1[1-4]([13579][26]|[02468][048])|15([1357][26]|[0246][048]|80)|(([2468][48]|[13579][26])00)|([1-9][6-9](0[48]|[13579][26]|[2468][048])|158[48]|159[26])"


"Normaljahr" Februar 28 Tage

Als Format nehme ich zuerst das gebräuchliche deutsche Format, also: TT.MM.JJJJ. Eine möglich Lösung wäre diese:
Alle Monate haben mindestens 1 bis 28 Tage. 0[1-9]|1\d|2[0-8].
Ein Jahr hat 1 bis 12 Monate 0[1-9]|1[0-2],
Die geben wir gleich dazu. (0[1-9]|1\d|2[0-8])\.(0[1-9]|1[0-2]).
Außer dem Februar haben alle Monate 29 und 30 Tage.(29|30)\.(0[13-9]|1[0-2])
und einige haben 31. 31\.(0[13578]|1[02])
Zusammengebaut: (((0[1-9]|1\d|2[0-8])\.(0[1-9]|1[0-2]))|(29|30)\.(0[13-9]|1[0-2])|(31\.(0[13578]|1[02])))\.\d{4}

Im englisch/amerikanischen Format (YYYY-MM-DD, YYYY/MM/DD) habe ich hier eine Besonderheit eingebaut. Der Verweis \1 bedeudet, dass die Eingabe der Eingabe des Musters in der 2. Klammer entsprechen muss. Wird also ein "-" oder ein "/" als Trennzeichen eingegeben, muss es an der 2. Stelle ebenfalls verwendet werden. Gemischt geht es also nicht.

ohne Schaltjahr-Datum Format: TT.MM.JJJJ
pattern="(((0[1-9]|1\d|2[0-8])\.(0[1-9]|1[0-2]))|(29|30)\.(0[13-9]|1[0-2])|(31\.(0[13578]|1[02])))\.\d{4}" >

28.02.2015
28.02.2016
30.04.2008
30.02.2015
31.00.2008
31.04.2008

ohne Schaltjahr - Datum Format: YYYY/MM/DD oder YYYY-MM-DD
pattern="\d{4}([/-])(((0[1-9]|1[0-2])\1(0[1-9]|1\d|2[1-8]))|(0[13-9]|1[0-2])\1(29|30)|(0[13578]|1[02])(\1)31)" >

2015/02/28
2015-02-28
2008-05-30
2015/02-28
31.05.2008
2015/02/29

Datum mit Schaltjahreberücksichtigung

Eine Idee war, jeweils ein Muster unter Berücksichtigung der Anzahl der Tage des Monats zu verwenden. Eines für Schaltjahre (Februar 29 Tage) und eines für Nicht-Schaltjahre (Februar 28 Tage). Diese werden dann als Alternative x|y gegenübergestellt. Die Auswahl geschieht dann einfach mit positiver Voraussage (?=.*(2004)). (2004 war ein Schaltjahr). Die Voraussage (wenn Jahr = Schaltjahr) switched zwischen den Alternativen.
x|(?=.*(Schaltjahr))y Wenn also 2004 eingegeben wurde, gilt y, ansonsten x.

Tja, und dann ist mir aufgefallen, dass ich nur den 29.Februar als Alternative brauche (wenn schaltjahr, dann 29.02.JJJJ), alles andere ist ja im Muster für "Nicht-Schaltjahre" schon drin.x|(?=.*(Schaltjahr))29.02.JAHR

Datum mit Berücksichtigung der Schaltjahre 0001-9999 )Format: TT.MM.JJJJ
pattern="(?!.*0000)(((0[1-9]|1\d|2[0-8])\.(0[1-9]|1[0-2]))|(29|30)\.(0[13-9]|1[0-2])|(31\.(0[13578]|1[02])))\.(19|20)\d{2}|(?=.*((([02468][048]|[13579][26])00)|(\d{2}(0[48]|[13579][26]|[2468][048]))))29\.02\.\d{4}">

29.02.2000
29.02.2004
29.02.2008
29.02.2015
29.02.2013
29.02.2004

UhrZeit

Zeit

Die Schreibweise von Uhrzeiten ist geregelt. In D und A wird mit dem Doppelpunkt getrennt. In der Schweiz mit dem normalen Punkt. in A und CH verzichtet man auf führende Null bei der Stunde, in D nicht.

24h D, A und CH Format: 00:00 - 23:59 (0.00 - 23.59)
pattern="([01]?\d|2[0-3])[:\.][0-5]\d"

12:03
11:55
12:03
12.03
11,55
24:00

Uhrzeit mit doppelter 2. Stunde Sommerzeitumstellung Format: 00:00 - 23:59 (0.00 - 23.59) 02:00A, 02:00B
pattern="(([01]?\d|2[0-3])[:\.][0-5]\d|0?2[:\.][0-5]\d[AB]"

12:03
02:15A
02:15B
12.03
03:15A
02:15C

24h mit Sekunden Format: 00:00:00 - 23:59:59
pattern="((2[0-3])|([01]\d)):[0-5]\d:[0-5]\d"

12h Format: 00:00 - 11:59
pattern="(1[0-2]|0\d):[0-5]\d [ap]m"

05:26 pm
11:59 pm
13:00pm
11.59 am

Wettkampfzeit Format: HH:MM:SS(,sss)
pattern="[0-5]?\d:[0-5]?\d:[0-5]\d(,\d{1,3})?"

0:04:31,981
0:4:31,3
4:31:981


Nato-Zeit

(Quelle: Wikipedia) Bei der NATO nutzt man das Date-Time-Group-Format. Die Minuten werden direkt an die Stunden angeschlossen. Wird die taktische Zeit mit dem Datum kombiniert, lautet die Schreibweise 010630Amar11 (06:30 Uhr am 1. März 2011) oder 131030Bjun11 (10:30 Uhr am 13. Juni 2011). „A“ steht die Mitteleuropäische WinterZeit (MEZ), „B“ für die Sommerzeit (MESZ). „Z“ steht für Koordinierte Weltzeit. Die Monate werden wie im Englischen abgekürzt.

ZuluZeitFormat: TTHHMMZmonJJ
pattern="\d[1-9]([01]\d|2[0-4])[0-5]\9[ABZ](jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d{2}"

010630Amar11
131030Bjun11
010630AMar11
150330Cjun11

..in der Datenverarbeitung

Numerische Zeit ISO8601 Format: JJJJ-MM-TT(T)hh:mm:ss
pattern="(\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[0-2]\d)|3[01])T([01]\d|2[0-3]):[0-5]\d:[0-5]\d"

2015-10-15T15:15:15
2015-10-15T15:15:15
2015.10.15T15:15:15
2015-10-15 15:15:15

Warum funktioniert das nicht?

Einige Beispiele die ich im Netz gefunden habe sind entweder zu sehr vereinfacht, zu kompliziert oder schlichtweg falsch. Einige sind offenbar nie überprüft worden. Die fehlerhaften (?) Beispiele eignen sich gut um das System richtig zu verstehen.

Datum (mit korrekter Monatslänge (keine Schaltjahr) Format: YYYY-MM-DD
pattern="(?:(?:0[1-9]|1[0-2])[\/\\-. ]?(?:0[1-9]|[12][0-9])|(?:(?:0[13-9]|1[0-2])[\/\\-. ]?30)|(?:(?:0[13578]|1[02])[\/\\-. ]?31))[\/\\-. ]?(?:19|20)[0-9]{2}"

2015-schrott-15
2015-miste

Egal was Du eingibst, der Validator ist immer zufrieden. Irgendwas stimmt nicht.

pattern="(?:19|20)(?:(?:[13579][26]|[02468][048])-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-9])|(?:(?!02)(?:0[1-9]|1[0-2])-(?:30))|(?:(?:0[13578]|1[02])-31))|(?:[0-9]{2}-(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:(?!02)(?:0[1-9]|1[0-2])-(?:29|30))|(?:(?:0[13578]|1[02])-31)))"

2015-01-28 2015-05-29
2015-03-29

Als erstes fällt auf, dass der Ersteller viele Klammerinhalte von Verweisen ausschliesen (?:....) wollte. Aber, es gibt nicht einen Verweis \1\2, also brauchen wir auch nichts auszuschliesen. Kürzen wir das Muster auch um dann ein paar unnötige Klammern wird es gleich übersichtlicher und verständlicher. Wozu diese Mühe?
Bei den Trennzeichen herrscht etwas Chaos [\/\\-. ]? Das Fragezeichen heißt: "kann aber muss nicht". Naja ein Trennung-zeichen wäre schon sinnvoll, je nach Anwendung. Unüblich sind in dieser Schreibweise die Punkte und Leerzeichen. Der - muss maskiert werden, wenn er nicht ganz vorn oder ganz hinten steht, ansonsten bedeutet er "von-bis". Hier sagt das Muster von "\" bis "." Das ist es auch, der das ganze unbrauchbar macht./ muss nicht maskiert werden.[0-9] könnte man kurz \d schreiben, auch Geschmacksache.