Date Validation Regular Expression

A properly formatted date should follow the ISO 8601 standard (YYYY-MM-DD) for consistency and international compatibility. This format is widely supported by programming languages and databases, making it ideal for data interchange and storage. For complete datetime validation, you may also need time validation.

Recommended Solution

This regular expression validates dates in ISO 8601 format (YYYY-MM-DD) with years from 1900-2099. It performs basic structural validation, but additional logic is recommended to verify day-month combinations (e.g., February 30th, leap years).

^(?:19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$

Explanation

^ - Start of the string.
(?:19|20)\d{2} - Year validation. Matches years from 1900-2099 (19XX or 20XX followed by two digits).
- - Hyphen separator (required by ISO 8601).
(0[1-9]|1[0-2]) - Month validation. Matches 01-09 or 10-12.
- - Hyphen separator.
(0[1-9]|[12]\d|3[01]) - Day validation. Matches 01-09, 10-29, or 30-31.
$ - End of the string.

Note: This regex validates the date format but doesn't enforce calendar rules (e.g., February having 28/29 days, or April having 30 days). For production use, combine this regex with additional validation using your language's date parsing libraries as shown in the implementation examples below.

Implementation

The implementations below include both regex validation and additional date logic to ensure calendar correctness (leap years, days per month, etc.).

const dateRegex = /^(?:19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
const isValidDate = (date) => {
  if (!dateRegex.test(date)) return false;
  
  // Additional validation for day-month combinations
  const [year, month, day] = date.split('-').map(Number);
  const dateObj = new Date(year, month - 1, day);
  
  return dateObj.getFullYear() === year &&
         dateObj.getMonth() === month - 1 &&
         dateObj.getDate() === day;
};

import re
from datetime import datetime

def is_valid_date(date):
  dateRegex = r"^(?:19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$"
  if not re.match(dateRegex, date):
    return False
  
  # Additional validation for day-month combinations
  try:
    datetime.strptime(date, '%Y-%m-%d')
    return True
  except ValueError:
    return False

use regex::Regex;
use chrono::NaiveDate;

fn is_valid_date(date: &str) -> bool {
  let dateRegex = Regex::new("^(?:19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$")
    .expect("Could not parse date validation regex");
  
  if !dateRegex.is_match(date) {
    return false;
  }
  
  // Additional validation for day-month combinations
  NaiveDate::parse_from_str(date, "%Y-%m-%d").is_ok()
}

package main

import (
  "regexp"
  "time"
)

func isValidDate(date string) bool {
  dateRegex := "^(?:19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$"
  re := regexp.MustCompile(dateRegex)
  
  if !re.MatchString(date) {
    return false
  }
  
  // Additional validation for day-month combinations
  _, err := time.Parse("2006-01-02", date)
  return err == nil
}

import Foundation

func isValidDate(_ date: String) -> Bool {
  let dateRegex = "^(?:19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$"
  let predicate = NSPredicate(format: "SELF MATCHES %@", dateRegex)
  
  if !predicate.evaluate(with: date) {
    return false
  }
  
  // Additional validation for day-month combinations
  let formatter = DateFormatter()
  formatter.dateFormat = "yyyy-MM-dd"
  return formatter.date(from: date) != nil
}

using System;
using System.Text.RegularExpressions;
using System.Globalization;

class Application {
  static bool IsValidDate(string date) {
    string dateRegex = "^(?:19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$";
    
    if (!Regex.IsMatch(date, dateRegex)) {
      return false;
    }
    
    // Additional validation for day-month combinations
    return DateTime.TryParseExact(date, "yyyy-MM-dd", 
      CultureInfo.InvariantCulture, 
      DateTimeStyles.None, out _);
  }
}

import java.util.regex.*;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;

public class Application {
  public static boolean isValidDate(String date) {
    String dateRegex = "^(?:19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$";
    Pattern pattern = Pattern.compile(dateRegex);
    
    if (!pattern.matcher(date).matches()) {
      return false;
    }
    
    // Additional validation for day-month combinations
    try {
      LocalDate.parse(date, DateTimeFormatter.ISO_LOCAL_DATE);
      return true;
    } catch (DateTimeParseException e) {
      return false;
    }
  }
}

<?php
function isValidDate($date) {
  $dateRegex = "^(?:19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$";
  
  if (!preg_match("/" . $dateRegex . "/", $date)) {
    return false;
  }
  
  // Additional validation for day-month combinations
  $d = DateTime::createFromFormat('Y-m-d', $date);
  return $d && $d->format('Y-m-d') === $date;
}
?>

Test Cases

These test cases include edge cases such as leap years, invalid day-month combinations, and boundary conditions. The validation includes both regex pattern matching and semantic date correctness.

Date String	Valid
2024-01-15
2024-12-31
2000-02-29
2024-02-29
1999-06-30
2023-07-04
2020-11-01
2024-02-30
2023-02-29
2024-04-31
2024-06-31
2024-09-31
2024-11-31
2024-13-01
2024-00-15
2024-01-00
2024-01-32
1899-12-31
2100-01-01
24-01-15
2024-1-15
2024-01-5
2024/01/15
15-01-2024
01-15-2024
(empty string)
not-a-date

Basic Validation

For a quick format check without strict ISO 8601 enforcement, you can use a basic regular expression that accepts various date separators (hyphen, slash, or dot). This is useful when you need flexibility in input format but still want a YYYY-MM-DD structure.

^\d{4}[-/.]\d{2}[-/.]\d{2}$

Explanation

^ - Start of the string.
\d{4} - Exactly four digits for the year.
[-/.] - Separator character (hyphen, slash, or dot).
\d{2} - Exactly two digits for the month.
[-/.] - Separator character.
\d{2} - Exactly two digits for the day.
$ - End of the string.

Warning: This basic pattern only validates the format structure. It does not validate whether the date is semantically correct (e.g., it would accept 9999-99-99). Always combine with additional validation for production use.

Implementation

const basicDateRegex = /^\d{4}[-/.]d{2}[-/.]d{2}$/;
const isValidDate = (date) => basicDateRegex.test(date);

import re

basic_date_regex = r'^\d{4}[-/.]\d{2}[-/.]\d{2}$'

def is_valid_date(date):
    return bool(re.match(basic_date_regex, date))

use regex::Regex;

fn is_valid_date(date: &str) -> bool {
    let re = Regex::new(r"^\d{4}[-/.]\d{2}[-/.]\d{2}$").unwrap();
    re.is_match(date)
}

package main

import (
    "regexp"
)

func isValidDate(date string) bool {
    re := regexp.MustCompile(`^\d{4}[-/.]\d{2}[-/.]\d{2}$`)
    return re.MatchString(date)
}

import Foundation

func isValidDate(_ date: String) -> Bool {
    let regex = try! NSRegularExpression(pattern: "^\d{4}[-/.]\d{2}[-/.]\d{2}$")
    return regex.firstMatch(in: date, range: NSRange(location: 0, length: date.utf16.count)) != nil
}

using System;
using System.Text.RegularExpressions;

class Program {
    static bool IsValidDate(string date) {
        return Regex.IsMatch(date, @"^\d{4}[-/.]\d{2}[-/.]\d{2}$");
    }
}

import java.util.regex.*;

public class DateValidator {
    public static boolean isValidDate(String date) {
        return Pattern.matches("^\d{4}[-/.]\d{2}[-/.]\d{2}$", date);
    }
}

<?php
function isValidDate($date) {
    return preg_match("/^\d{4}[-/.]\d{2}[-/.]\d{2}$/", $date);
}

Test Cases

Date String	Valid
2024-01-15
2024/01/15
2024.01.15
2024-12-31
2000-02-29
2024-02-30
2024-13-01
9999-99-99
2024-1-15
24-01-15
2024-01-5
15-01-2024
(empty string)
not-a-date