PHP Regex zum Überprüfen des Datums ist im Format JJJJ-MM-TT

Ich versuche zu überprüfen, ob die von Endbenutzern eingegebenen Daten im JJJJ-MM-TT enthalten sind. Regex war noch nie meine Stärke. Ich erhalte immer wieder einen falschen Rückgabewert für das von mir eingerichtete preg_match ().

Ich gehe also davon aus, dass ich den unten beschriebenen regulären Ausdruck durcheinander gebracht habe.

$date="2012-09-12";

if (preg_match("^[0-9]{4}-[0-1][0-9]-[0-3][0-9]$",$date))
    {
        return true;
    }else{
        return false;
    }

Irgendwelche Gedanken?

Versuche dies.

$date="2012-09-12";

if (preg_match("/^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])$/",$date)) {
    return true;
} else {
    return false;
}

Es ist wahrscheinlich besser, dafür einen anderen Mechanismus zu verwenden.

Die moderne Lösung mit DateTime:

$dt = DateTime::createFromFormat("Y-m-d", $date);
return $dt !== false && !array_sum($dt::getLastErrors());

Dies validiert auch die Eingabe: $dt !== falsestellt sicher, dass das Datum mit dem angegebenen Format analysiert werden kann, und der array_sumTrick ist eine knappe Methode, um sicherzustellen, dass PHP keine "Monatsverschiebung" durchgeführt hat (z. B. wenn man bedenkt, dass der 32. Januar der 1. Februar ist). Siehe DateTime::getLastErrors()für weitere Informationen.

Old-School-Lösung mit explodeund checkdate:

list($y, $m, $d) = array_pad(explode('-', $date, 3), 3, 0);
return ctype_digit("$y$m$d") && checkdate($m, $d, $y);

Dies bestätigt, dass die Eingabe ebenfalls ein gültiges Datum ist. Sie können das natürlich mit einer Regex tun, aber es wird mehr Aufhebens geben - und der 29. Februar kann überhaupt nicht mit einer Regex validiert werden.

Der Nachteil dieses Ansatzes besteht darin, dass Sie sehr vorsichtig sein müssen, um alle möglichen "schlechten" Eingaben abzulehnen, ohne unter keinen Umständen eine Benachrichtigung zu senden. Hier ist wie:

• explodeist auf die Rückgabe von 3 Token beschränkt (so dass, wenn die Eingabe "1-2-3-4" ist, $d"3-4" wird)
• ctype_digit wird verwendet, um sicherzustellen, dass die Eingabe keine nicht numerischen Zeichen enthält (außer den Bindestrichen).
• array_padwird verwendet (mit einem Standardwert, der checkdatezum Fehlschlagen führt), um sicherzustellen, dass genügend Elemente zurückgegeben werden, sodass bei einer Eingabe von "1-2" list()keine Benachrichtigung ausgegeben wird

JJJJ-MM-TT: /^((((19|[2-9]\d)\d{2})\-(0[13578]|1[02])\-(0[1-9]|[12]\d|3[01]))|(((19|[2-9]\d)\d{2})\-(0[13456789]|1[012])\-(0[1-9]|[12]\d|30))|(((19|[2-9]\d)\d{2})\-02\-(0[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))\-02\-29))$/g

JJJJ / MM / TT: /^((((19|[2-9]\d)\d{2})\/(0[13578]|1[02])\/(0[1-9]|[12]\d|3[01]))|(((19|[2-9]\d)\d{2})\/(0[13456789]|1[012])\/(0[1-9]|[12]\d|30))|(((19|[2-9]\d)\d{2})\/02\/(0[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))\/02\/29))$/g

MM-TT-JJJJ: /^(((0[13578]|1[02])\-(0[1-9]|[12]\d|3[01])\-((19|[2-9]\d)\d{2}))|((0[13456789]|1[012])\-(0[1-9]|[12]\d|30)\-((19|[2-9]\d)\d{2}))|(02\-(0[1-9]|1\d|2[0-8])\-((19|[2-9]\d)\d{2}))|(02\-29\-((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))))$/g

MM / TT / JJJJ: /^(((0[13578]|1[02])\/(0[1-9]|[12]\d|3[01])\/((19|[2-9]\d)\d{2}))|((0[13456789]|1[012])\/(0[1-9]|[12]\d|30)\/((19|[2-9]\d)\d{2}))|(02\/(0[1-9]|1\d|2[0-8])\/((19|[2-9]\d)\d{2}))|(02\/29\/((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))))$/g

DD / MM / JJJJ : /^(((0[1-9]|[12]\d|3[01])\/(0[13578]|1[02])\/((19|[2-9]\d)\d{2}))|((0[1-9]|[12]\d|30)\/(0[13456789]|1[012])\/((19|[2-9]\d)\d{2}))|((0[1-9]|1\d|2[0-8])\/02\/((19|[2-9]\d)\d{2}))|(29\/02\/((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))))$/g

DD / MM / JJJJ : /^(((0[1-9]|[12]\d|3[01])\-(0[13578]|1[02])\-((19|[2-9]\d)\d{2}))|((0[1-9]|[12]\d|30)\-(0[13456789]|1[012])\-((19|[2-9]\d)\d{2}))|((0[1-9]|1\d|2[0-8])\-02\-((19|[2-9]\d)\d{2}))|(29\-02\-((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))))$/g

Kriterien:

Jedes durch 4 teilbare Jahr ist ein Schaltjahr, außer wenn es durch 100 teilbar ist, es sei denn, es ist durch 400 teilbar. Also:

2004 - leap year - divisible by 4
1900 - not a leap year - divisible by 4, but also divisible by 100
2000 - leap year - divisible by 4, also divisible by 100, but divisible by 400

Der Februar hat 29 Tage in einem Schaltjahr und 28 Tage, wenn kein Schaltjahr

30 Tage im April, Juni, September und November

31 Tage im Januar, März, Mai, Juli, August, Oktober und Dezember

Prüfung:

Die folgenden Daten sollten alle die Validierung bestehen:

1976-02-29
2000-02-29
2004-02-29
1999-01-31

Die folgenden Daten sollten alle nicht validiert werden:

2015-02-29
2015-04-31
1900-02-29
1999-01-32
2015-02-00

Angebot:

Wir werden auf Daten vom 1. Januar 1000 bis 31. Dezember 2999 testen. Technisch gesehen wurde der derzeit verwendete Gregorianische Kalender erst 1753 für das britische Empire und zu verschiedenen Jahren im 17. Jahrhundert für Länder in Europa verwendet, aber ich werde es nicht tun mach dir darüber Sorgen.

Regex zum Testen für ein Schaltjahr:

Die durch 400 teilbaren Jahre:

1200|1600|2000|2400|2800
can be shortened to:
(1[26]|2[048])00

if you wanted all years from 1AD to 9999 then this would do it:
(0[48]|[13579][26]|[2468][048])00
if you're happy with accepting 0000 as a valid year then it can be shortened:
([13579][26]|[02468][048])00

Die durch 4 teilbaren Jahre:

[12]\d([02468][048]|[13579][26])

Die durch 100 teilbaren Jahre:

[12]\d00

Nicht teilbar durch 100:

[12]\d([1-9]\d|\d[1-9])

Die Jahre teilbar durch 100 aber nicht durch 400:

((1[1345789])|(2[1235679]))00

Teilbar durch 4 aber nicht durch 100:

[12]\d([2468][048]|[13579][26]|0[48])

Die Schaltjahre:

divisible by 400 or (divisible by 4 and not divisible by 100)
((1[26]|2[048])00)|[12]\d([2468][048]|[13579][26]|0[48])

Nicht teilbar durch 4:

[12]\d([02468][1235679]|[13579][01345789])

Kein Schaltjahr:

Not divisible by 4 OR is divisible by 100 but not by 400
([12]\d([02468][1235679]|[13579][01345789]))|(((1[1345789])|(2[1235679]))00)

Gültiger Monat und Tag außer Februar (MM-DD):

((01|03|05|07|08|10|12)-(0[1-9]|[12]\d|3[01]))|((04|06|09|11)-(0[1-9]|[12]\d|30))
shortened to:
((0[13578]|1[02])-(0[1-9]|[12]\d|3[01]))|((0[469]|11)-(0[1-9]|[12]\d|30))

Februar mit 28 Tagen:

02-(0[1-9]|1\d|2[0-8])

Februar mit 29 Tagen:

02-(0[1-9]|[12]\d)

Gültiges Datum:

(leap year followed by (valid month-day-excluding-february OR 29-day-february)) 
OR
(non leap year followed by (valid month-day-excluding-february OR 28-day-february))

((((1[26]|2[048])00)|[12]\d([2468][048]|[13579][26]|0[48]))-((((0[13578]|1[02])-(0[1-9]|[12]\d|3[01]))|((0[469]|11)-(0[1-9]|[12]\d|30)))|(02-(0[1-9]|[12]\d))))|((([12]\d([02468][1235679]|[13579][01345789]))|((1[1345789]|2[1235679])00))-((((0[13578]|1[02])-(0[1-9]|[12]\d|3[01]))|((0[469]|11)-(0[1-9]|[12]\d|30)))|(02-(0[1-9]|1\d|2[0-8]))))

Dort haben Sie also eine Regex für Daten zwischen dem 1. Januar 1000 und dem 31. Dezember 2999 im Format JJJJ-MM-TT.

Ich vermute, es kann ziemlich verkürzt werden, aber das überlasse ich jemand anderem.

Das stimmt mit allen gültigen Daten überein. Wenn Sie möchten, dass es nur gültig ist, wenn es nur ein Datum und nichts anderes enthält, wickeln Sie es ^( )$wie folgt ein:

^(((((1[26]|2[048])00)|[12]\d([2468][048]|[13579][26]|0[48]))-((((0[13578]|1[02])-(0[1-9]|[12]\d|3[01]))|((0[469]|11)-(0[1-9]|[12]\d|30)))|(02-(0[1-9]|[12]\d))))|((([12]\d([02468][1235679]|[13579][01345789]))|((1[1345789]|2[1235679])00))-((((0[13578]|1[02])-(0[1-9]|[12]\d|3[01]))|((0[469]|11)-(0[1-9]|[12]\d|30)))|(02-(0[1-9]|1\d|2[0-8])))))$

Wenn Sie es für einen optionalen Datumseintrag wünschen (dh es kann ein leeres oder ein gültiges Datum sein), fügen Sie es ^$|am Anfang wie folgt hinzu:

^$|^(((((1[26]|2[048])00)|[12]\d([2468][048]|[13579][26]|0[48]))-((((0[13578]|1[02])-(0[1-9]|[12]\d|3[01]))|((0[469]|11)-(0[1-9]|[12]\d|30)))|(02-(0[1-9]|[12]\d))))|((([12]\d([02468][1235679]|[13579][01345789]))|((1[1345789]|2[1235679])00))-((((0[13578]|1[02])-(0[1-9]|[12]\d|3[01]))|((0[469]|11)-(0[1-9]|[12]\d|30)))|(02-(0[1-9]|1\d|2[0-8])))))$

Sie können es so machen:

if (preg_match("/\d{4}\-\d{2}-\d{2}/", $date)) {
    echo 'true';
} else {
    echo 'false';
}

aber du solltest besser dieses verwenden:

$date = DateTime::createFromFormat('Y-m-d', $date);
if ($date) {
    echo $date -> format('Y-m-d');
}

In diesem Fall erhalten Sie ein Objekt, das einfacher zu verwenden ist als nur Zeichenfolgen.

Ich weiß, dass dies eine alte Frage ist. Aber ich denke ich habe eine gute Lösung.

$date = "2016-02-21";
$format = "Y-m-d";

if(date($format, strtotime($date)) == date($date)) {
    echo "true";
} else {
    echo "false";
}

Du kannst es versuchen. Wenn Sie das Datum auf 21.02.2016 ändern, ist das Echo falsch. Und wenn Sie das Format danach auf dmY ändern, ist das Echo wahr.

Mit diesem einfachen Code sollten Sie in der Lage sein zu überprüfen, welches Datumsformat verwendet wird, ohne es durch den regulären Ausdruck zu überprüfen.

Vielleicht gibt es eine Person, die es in jedem Fall testet. Aber ich denke, meine Idee ist allgemein gültig. Für mich scheint es logisch.

Sie können ein preg_match mit einer Checkdate-PHP-Funktion verwenden

$date  = "2012-10-05";
$split = array();
if (preg_match ("/^([0-9]{4})-([0-9]{2})-([0-9]{2})$/", $date, $split))
{
    return checkdate($split[2], $split[3], $split[1]);
}

return false;

preg_match benötigt ein / oder ein anderes Zeichen als Trennzeichen.

preg_match("/^[0-9]{4}-[0-1][0-9]-[0-3][0-9]$/",$date)

Sie sollten auch die Gültigkeit dieses Datums überprüfen, damit Sie nicht mit so etwas wie 9999-19-38 enden

bool checkdate ( int $month , int $day , int $year )

Sie können es auch so machen:

if (DateTime::createFromFormat('Y-m-d', $date)->format('Y-m-d') === $date) {

    // date is correctly formatted and valid, execute some code

}

Dies überprüft nicht nur das Format, sondern auch die Gültigkeit des Datums selbst, da DateTimenur gültige Daten erstellt werden und dies mit der Eingabe übereinstimmen muss.

Sie können verwenden

function validateDate($date, $format = 'Y-m-d H:i:s')
{
    $d = DateTime::createFromFormat($format, $date);
    return $d && $d->format($format) == $date;
}

$date="2012-09-12";    
echo validateDate($date, 'Y-m-d'); // true or false

Überprüfen und validieren Sie das YYYY-MM-DDDatum in einer einzeiligen Anweisung

function isValidDate($date) {
    return preg_match("/^(\d{4})-(\d{1,2})-(\d{1,2})$/", $date, $m)
        ? checkdate(intval($m[2]), intval($m[3]), intval($m[1]))
        : false;
}

Die Ausgabe wird sein:

var_dump(isValidDate("2018-01-01")); // bool(true)
var_dump(isValidDate("2018-1-1"));   // bool(true)
var_dump(isValidDate("2018-02-28")); // bool(true)
var_dump(isValidDate("2018-02-30")); // bool(false)

Tag und Monat ohne führende Null sind zulässig. Wenn Sie dies nicht zulassen möchten, sollte der reguläre Ausdruck wie folgt lauten:

"/^(\d{4})-(\d{2})-(\d{2})$/"

Wenn Sie diesem Datumstyp entsprechen möchten, verwenden Sie:

preg_match("~^\d{4}-\d{2}-\d{2}$~", $date)

Dies sollte Ihnen mitteilen, ob das Format gültig ist und ob das Eingabedatum gültig ist.

    $datein = '2012-11-0';

    if(preg_match('/^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])$/', $datein)){
        echo 'good';
    }else{
        echo 'no good';
    }

Wenn dies hilfreich ist, finden Sie hier einen regulären Ausdruck für das jnY-Format (das Jahr muss größer als 2018 sein):

if (preg_match('/^([1-9]|[1-2][0-9]|[3][0-1])\-([1-9]|[1][0-2])\-(?:20)([1][8-9]|[2-9][0-9])$/', $date)) {
   // Do stuff
}

Format 1: $ format1 = "2012-12-31";

Format 2: $ format2 = "31-12-2012";

if (preg_match("/^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])$/",$format1)) {
    return true;
} else {
    return false;
}

if (preg_match("/^(0[1-9]|[1-2][0-9]|3[0-1])-(0[1-9]|1[0-2])-[0-9]{4}$/",$format2)) {
    return true;
} else {
    return false;
}

Wahrscheinlich nützlich für jemanden:

$patterns = array(
            'Y'           =>'/^[0-9]{4}$/',
            'Y-m'         =>'/^[0-9]{4}(-|\/)([1-9]|0[1-9]|1[0-2])$/',
            'Y-m-d'       =>'/^[0-9]{4}(-|\/)([1-9]|0[1-9]|1[0-2])(-|\/)([1-9]|0[1-9]|[1-2][0-9]|3[0-1])$/',
            'Y-m-d H'     =>'/^[0-9]{4}(-|\/)([1-9]|0[1-9]|1[0-2])(-|\/)([1-9]|0[1-9]|[1-2][0-9]|3[0-1])\s(0|[0-1][0-9]|2[0-4])$/',
            'Y-m-d H:i'   =>'/^[0-9]{4}(-|\/)([1-9]|0[1-9]|1[0-2])(-|\/)([1-9]|0[1-9]|[1-2][0-9]|3[0-1])\s(0|[0-1][0-9]|2[0-4]):?(0|[0-5][0-9]|60)$/',
            'Y-m-d H:i:s' =>'/^[0-9]{4}(-|\/)([1-9]|0[1-9]|1[0-2])(-|\/)([1-9]|0[1-9]|[1-2][0-9]|3[0-1])\s(0|[0-1][0-9]|2[0-4]):?((0|[0-5][0-9]):?(0|[0-5][0-9])|6000|60:00)$/',
        );
echo preg_match($patterns['Y'], '1996'); // true
echo preg_match($patterns['Y'], '19966'); // false
echo preg_match($patterns['Y'], '199z'); // false
echo preg_match($patterns['Y-m'], '1996-0'); // false
echo preg_match($patterns['Y-m'], '1996-09'); // true
echo preg_match($patterns['Y-m'], '1996-1'); // true
echo preg_match($patterns['Y-m'], '1996/1'); // true
echo preg_match($patterns['Y-m'], '1996/12'); // true
echo preg_match($patterns['Y-m'], '1996/13'); // false
echo preg_match($patterns['Y-m-d'], '1996-11-1'); // true
echo preg_match($patterns['Y-m-d'], '1996-11-0'); // false
echo preg_match($patterns['Y-m-d'], '1996-11-32'); // false
echo preg_match($patterns['Y-m-d H'], '1996-11-31 0'); // true
echo preg_match($patterns['Y-m-d H'], '1996-11-31 00'); // true
echo preg_match($patterns['Y-m-d H'], '1996-11-31 24'); // true
echo preg_match($patterns['Y-m-d H'], '1996-11-31 25'); // false
echo preg_match($patterns['Y-m-d H:i'], '1996-11-31 2400'); // true
echo preg_match($patterns['Y-m-d H:i'], '1996-11-31 24:00'); // true
echo preg_match($patterns['Y-m-d H:i'], '1996-11-31 24:59'); // true
echo preg_match($patterns['Y-m-d H:i'], '1996-11-31 24:60'); // true
echo preg_match($patterns['Y-m-d H:i'], '1996-11-31 24:61'); // false
echo preg_match($patterns['Y-m-d H:i'], '1996-11-31 24:61'); // false
echo preg_match($patterns['Y-m-d H:i:s'], '1996-11-31 24:6000'); // true
echo preg_match($patterns['Y-m-d H:i:s'], '1996-11-31 24:60:00'); // true
echo preg_match($patterns['Y-m-d H:i:s'], '1996-11-31 24:59:59'); // true
echo preg_match($patterns['Y-m-d H:i:s'], '1996-11-31 24:59:60'); // false
echo preg_match($patterns['Y-m-d H:i:s'], '1996-11-31 24:60:01'); // false

Funktion zum Überprüfen des generischen Datumsformats:

function validateDate($date, $format = 'Y-m-d') {
  $d = DateTime::createFromFormat($format, $date);
  return $d && $d->format($format) == $date;
}

Ausführungsbeispiel:

var_dump(validateDate('2021-02-28')); // true
var_dump(validateDate('2021-02-29')); // false

Es hängt alles davon ab, wie streng diese Funktion sein soll. Wenn Sie beispielsweise keine Monate über 12 und keine Tage über 31 zulassen möchten (unabhängig vom Monat, für den das Schreiben einer Datumslogik erforderlich ist), kann dies ziemlich kompliziert werden:

function checkDate($date)
{
  $regex = '/^' . 
    '(' .

    // Allows years 0000-9999
    '(?:[0-9]{4})' .
    '\-' .

    // Allows 01-12
    '(?:' .
    '(?:01)|(?:02)|(?:03)|(?:04)|(?:05)|(?:06)|(?:07)|(?:08)|(?:09)|(?:10)|' .
    '(?:11)|(?:12)' .
    ')' .
    '\-' .

    // Allows 01-31
    '(?:' .
    '(?:01)|(?:02)|(?:03)|(?:04)|(?:05)|(?:06)|(?:07)|(?:08)|(?:09)|(?:10)|' .
    '(?:11)|(?:12)|(?:13)|(?:14)|(?:15)|(?:16)|(?:17)|(?:18)|(?:19)|(?:20)|' .
    '(?:21)|(?:22)|(?:23)|(?:24)|(?:25)|(?:26)|(?:27)|(?:28)|(?:29)|(?:30)|' .
    '(?:31)' .
    ')' .

    '$/';

  if ( preg_match($regex, $date) ) {
    return true;
  }

  return false;
}

$result = checkDate('2012-09-12');

Persönlich würde ich einfach gehen für: /^([0-9]{4}\-([0-9]{2}\-[0-9]{2})$/

Um mit Datumsangaben in PHP zu arbeiten, sollten Sie den PHP-Standard befolgen, damit der angegebene reguläre Ausdruck sicherstellt, dass Sie ein gültiges Datum haben, das mit PHP arbeiten kann.

    preg_match("/^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])$/",$date)

Diese Methode kann nützlich sein, um das Datum in PHP zu überprüfen. Die derzeitige Methode ist für das Format MM / TT / JJJJ. Sie müssen die Parameterfolge in checkdate gemäß Ihrem Format und dem Trennzeichen in explode aktualisieren .

    function isValidDate($dt)
    {
        $dtArr = explode('/', $dt);
        if (!empty($dtArr[0]) && !empty($dtArr[1]) && !empty($dtArr[2])) {
            return checkdate((int) $dtArr[0], (int) $dtArr[1], (int) $dtArr[2]);
        } else {
            return false;
        }
    }

[Wenn Sie Symfony 4.1.2 verwenden, versuchen Sie dies] [1]

  $validDate = explode("-",$request->get('date'));
        if (checkdate(filter_var($validDate[1],FILTER_SANITIZE_NUMBER_INT),filter_var($validDate[0],FILTER_SANITIZE_NUMBER_INT),filter_var($validDate[2],FILTER_SANITIZE_NUMBER_INT))){
            $date = date_create(filter_var($request->get('date'),FILTER_SANITIZE_SPECIAL_CHARS));
        }else{
            return $this->redirectToRoute('YOUR_ROUTE');
        }

Ab Laravel 5.7 und Datumsformat dh: 31.12.2019

function checkDateFormat(string $date): bool
{
    return preg_match("/^(0[1-9]|1[0-2])\/(0[1-9]|[1-2][0-9]|3[0-1])\/[0-9]{4}$/", $date);
}

Ich suchte nach "wie man das Datum validiert" und fand diese Lösung. Es ist alt, aber ich werde die folgende Methode teilen, die verwendet werden kann, um das Datum in PHP zu validieren.

checkdate('01', '31', '2019')