PHP Regex pour vérifier la date est au format AAAA-MM-JJ

J'essaie de vérifier que les dates saisies par les utilisateurs finaux sont dans le AAAA-MM-JJ. Regex n'a jamais été mon point fort, j'obtiens toujours une fausse valeur de retour pour le preg_match () que j'ai configuré.

Donc, je suppose que j'ai fait un gâchis de l'expression régulière, détaillé ci-dessous.

$date="2012-09-12";

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

Des pensées?

Essaye ça.

$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;
}

Il est probablement préférable d'utiliser un autre mécanisme pour cela.

La solution moderne, avec DateTime:

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

Cela valide aussi l'entrée: $dt !== falsegarantit que la date peut être analysée avec le format spécifié et l' array_sumastuce est un moyen laconique de s'assurer que PHP n'a pas fait de "décalage de mois" (par exemple, considérez que le 32 janvier est le 1er février). Voir DateTime::getLastErrors()pour plus d'informations.

Solution old-school avec explodeet checkdate:

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

Cela confirme que l'entrée est également une date valide. Vous pouvez le faire avec une regex bien sûr, mais ça va être plus compliqué - et le 29 février ne peut pas du tout être validé avec une regex.

L'inconvénient de cette approche est qu'il faut être très prudent pour rejeter toutes les «mauvaises» entrées possibles sans émettre d'avis en aucune circonstance. Voici comment:

• explodeest limité à renvoyer 3 jetons (de sorte que si l'entrée est "1-2-3-4", $ddeviendra "3-4")
• ctype_digit est utilisé pour s'assurer que l'entrée ne contient pas de caractères non numériques (à l'exception des tirets)
• array_padest utilisé (avec une valeur par défaut qui entraînera l' checkdateéchec) pour s'assurer que suffisamment d'éléments sont renvoyés pour que si l'entrée est "1-2" list()n'émette pas de notification

aaaa-mm-jj: /^((((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

aaaa / mm / jj: /^((((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-jj-aaaa: /^(((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 / jj / aaaa: /^(((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

jj / mm / aaaa: /^(((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

jj-mm-aaaa: /^(((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

Critères:

Chaque année divisible par 4 est une année bissextile, sauf lorsqu'elle est divisible par 100 à moins qu'elle ne soit divisible par 400. Donc:

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

Février a 29 jours dans une année bissextile et 28 jours si ce n'est pas une année bissextile

30 jours en avril, juin, septembre et novembre

31 jours en janvier, mars, mai, juillet, août, octobre et décembre

Tester:

Les dates suivantes devraient toutes passer la validation:

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

Les dates suivantes devraient toutes échouer à la validation:

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

Intervalle:

Nous allons tester les dates du 1er janvier 1000 au 31 décembre 2999. Techniquement, le calendrier grégorien actuellement utilisé n'est entré en vigueur qu'en 1753 pour l'Empire britannique et à diverses années dans les années 1600 pour les pays d'Europe, mais je ne vais pas inquiétez-vous à ce sujet.

Regex à tester pour une année bissextile:

Les années divisibles par 400:

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

Les années divisibles par 4:

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

Les années divisibles par 100:

[12]\d00

Non divisible par 100:

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

Les années divisibles par 100 mais pas par 400:

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

Divisible par 4 mais pas par 100:

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

Les années bissextiles:

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])

Non divisible par 4:

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

Pas une année bissextile:

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

Mois et jour valides hors février (MM-JJ):

((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))

Février avec 28 jours:

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

Février avec 29 jours:

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

Date valide:

(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]))))

Voilà donc une expression régulière pour les dates entre le 1er janvier 1000 et le 31 décembre 2999 au format AAAA-MM-JJ.

Je soupçonne que cela peut être raccourci un peu, mais je laisse cela à quelqu'un d'autre.

Cela correspondra à toutes les dates valides. Si vous voulez qu'il ne soit valide que lorsqu'il ne contient qu'une seule date et rien d'autre, enveloppez-le ^( )$comme suit:

^(((((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])))))$

Si vous le souhaitez pour une entrée de date facultative (c'est-à-dire qu'il peut être vide ou une date valide), ajoutez ^$|au début, comme ceci:

^$|^(((((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])))))$

Vous pouvez le faire de cette façon:

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

mais vous feriez mieux d'utiliser celui-ci:

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

dans ce cas, vous obtiendrez un objet plus facile à utiliser que de simples chaînes.

Je sais que c'est une vieille question. Mais je pense avoir une bonne solution.

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

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

Tu peux l'essayer. Si vous modifiez la date au 21.02.2016, l'écho est faux. Et si vous changez le format après cela en dmY, l'écho est vrai.

Avec ce code simple, vous devriez être en mesure de vérifier quel format de date est utilisé sans le vérifier par le regex.

Peut-être qu'il y a une personne qui le testera sur chaque cas. Mais je pense que mon idée est généralement valable. Pour moi, cela semble logique.

Vous pouvez utiliser un preg_match avec une fonction php checkdate

$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 a besoin d'un / ou d'un autre caractère comme délimiteur.

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

vous devriez également vérifier la validité de cette date pour ne pas vous retrouver avec quelque chose comme 9999-19-38

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

Vous pouvez également le faire comme ceci:

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

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

}

Cela vérifiera non seulement le format, mais également la validité de la date auto, car DateTimene créera que des dates valides et cela doit correspondre à l'entrée.

vous pouvez utiliser

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

Vérifier et valider la YYYY-MM-DDdate en une seule ligne

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;
}

La sortie sera:

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)

Le jour et le mois sans zéro non significatif sont autorisés. Si vous ne souhaitez pas autoriser cela, l'expression rationnelle doit être:

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

Si vous souhaitez faire correspondre ce type de date, utilisez:

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

Cela devrait vous dire si le format est valide et si la date d'entrée est valide.

    $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';
    }

Si cela vous aide, voici une expression régulière pour le format jnY (l'année doit être supérieure à 2018):

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;
}

Probablement utile à quelqu'un:

$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

Fonction pour valider le format de date générique:

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

Exemple d'exécution:

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

Tout dépend de la rigueur de cette fonction. Par exemple, si vous ne voulez pas autoriser les mois au-dessus de 12 et les jours au-dessus de 31 (pas en fonction du mois, cela nécessiterait d'écrire une logique de date), cela pourrait devenir assez compliqué:

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');

Personnellement, j'irais simplement pour: /^([0-9]{4}\-([0-9]{2}\-[0-9]{2})$/

Pour travailler avec des dates en php, vous devez suivre le standard php afin que le regex donné garantisse que vous avez une date valide qui peut fonctionner avec PHP.

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

Cette méthode peut être utile pour valider la date en PHP. La méthode actuelle est pour le format mm / jj / aaaa. Vous devez mettre à jour la séquence de paramètres dans la date de contrôle selon votre format et le délimiteur dans éclaté .

    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;
        }
    }

[Si vous utilisez Symfony 4.1.2, essayez ceci] [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');
        }

À partir de Laravel 5.7 et format de date, par exemple: 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);
}

Je cherchais "comment valider la date" et j'ai trouvé cette solution, son ancienne mais je partagerai ci-dessous la méthode qui peut être utilisée pour valider la date en php,

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