s2e-lab/RegexEval huggingface dataset:
This expression validates a date-time field in European d/m/y h:m:s format. The days are validated for the given month and year. Leap years are validated for all 4 digits years from 1600-9999, and all 2 digits years except 00
Match examples:
- "29/02/2004 20:15:27"
- "29/2/04 8:9:5"
- "31/3/2004 9:20:17"
Non-match examples:
- "29/02/2003 20:15:15"
- "2/29/04 20:15:15"
Regular expression: ^((((31\/(0?[13578]|1[02]))|((29|30)\/(0?[1,3-9]|1[0-2])))\/(1[6-9]|[2-9]\d)?\d{2})|(29\/0?2\/(((1[6-9]|[2-9]\d)?(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))))|(0?[1-9]|1\d|2[0-8])\/((0?[1-9])|(1[0-2]))\/((1[6-9]|[2-9]\d)?\d{2})) (20|21|22|23|[0-1]?\d):[0-5]?\d:[0-5]?\d$
This regular expression validates a number NOT 0, with no more than 5 places ahead and 3 places behind the decimal point.
Match examples:
- "1"
- "12345.123"
- "0.5"
Non-match examples:
- "0"
- "0.0"
Regular expression: (?!^0*$)(?!^0*\.0*$)^\d{1,5}(\.\d{1,3})?$
This regular expression matches and captures any text enclosed by two consecutive "@" symbols, where the enclosed text consists of one or more non-whitespace characters. Spaces inside the enclosed text are not allowed for a match.
Match examples:
- "@@test@@"
- "@@name@@"
- "@@2342@@"
Non-match examples:
- "@test@"
- "@@na me@@"
Regular expression: @{2}((\S)+)@{2}
This regular expression matches one or more consecutive letters in a string, where the first letter is uppercase (A-Z) and the subsequent letters are lowercase (a-z).
Match examples:
- "strFirstName"
- "intAgeInYears"
- "Where the Wild Things Are"
Non-match examples:
- "123"
- "abc"
Regular expression: [A-Z][a-z]+
A regular expression that matches numbers. Integers or decimal numbers with or without the exponential form.
Match examples:
- "23"
- "-17.e23"
- "+.23e+2"
Non-match examples:
- "+.e2"
- "23.17.5"
Regular expression: ^[+-]?([0-9]*\.?[0-9]+|[0-9]+\.?[0-9]*)([eE][+-]?[0-9]+)?$
This regular expression is used to validate and capture data that follows the specific pattern of dates in the YYYY-MM-DD format(could also be single M or single D), where each component is represented by digits.
Match examples:
- "2002-11-03"
- "2007-17-08"
- "9999-99-99"
Non-match examples:
- "2002/17/18"
- "2002.18.45"
Regular expression: ([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})
This matches an IP address, putting each number in its own group that can be retrieved by number. It only permits numbers in the range 0-255.
Match examples:
- "0.0.0.0"
- "255.255.255.02"
- "192.168.0.136"
Non-match examples:
- "256.1.3.4"
- "023.44.33.22"
Regular expression: ^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$
This regular expression is used to validate and capture monetary values, including both whole numbers and decimal values, with optional commas as thousands separators and an optional dollar sign at the beginning.
Match examples:
- "$1,234.50"
- "$0.70"
- ".7"
Non-match examples:
- "$0,123.50"
- "$00.5"
Regular expression: ^\$?([1-9]{1}[0-9]{0,2}(\,[0-9]{3})*(\.[0-9]{0,2})?|[1-9]{1}[0-9]{0,}(\.[0-9]{0,2})?|0(\.[0-9]{0,2})?|(\.[0-9]{1,2})?)$
This expression validates a date field in the European DD-MM-YYYY format. Days are validate for the given month and year.
Match examples:
- "05-01-2002"
- "29-02-2004"
- "31-12-2002"
Non-match examples:
- "1-1-02"
- "29-02-2002"
Regular expression: ^(((((0[1-9])|(1\d)|(2[0-8]))-((0[1-9])|(1[0-2])))|((31-((0[13578])|(1[02])))|((29|30)-((0[1,3-9])|(1[0-2])))))-((20[0-9][0-9]))|(29-02-20(([02468][048])|([13579][26]))))$
This regular expression is used to validate decimal numbers that can have an optional leading zero, at least one digit before and after the decimal point (if present), and may allow for either a dot or comma as a decimal separator. Excludes all alphanumeric character
Match examples:
- "123456.123456"
- "123456,123456"
- "123456"
Non-match examples:
- "123a.123"
- "123a,123"
Regular expression: ^\d*[0-9](|.\d*[0-9]|,\d*[0-9])?$
Checks whether the string specified is in the same format as the UK postcode format.
It allows:
A = Letter
N = Number
AN NAA, ANA NAA, ANN NAA, AAN NAA, AAA NAA (rare), AANN NAA, AANA NAA
It gives the option to have the two parts of the uk postcode to be separated by a space or a hyphen.
(restriction is set to all-capitals)
Match examples:
- "AA11 1AA"
- "AA1A 1AA"
- "A11-1AA"
Non-match examples:
- "111 AAA"
- "1AAA 1AA"
Regular expression: ^([A-Z]{1,2}[0-9]{1,2}|[A-Z]{3}|[A-Z]{1,2}[0-9][A-Z])( |-)[0-9][A-Z]{2}
This regular expression is used to match HTML <img> tags with any attributes, excluding self-closing tags (those ending with "/>"). Use this along with this replacement string &lt;img\1 /&gt; to convert image tags to XHTML compliant image tags.
Match examples:
- "<img src="bob">"
- "<img%("]jCkOZt=1uT_Rl>"
- "<imgDjxWWIdhH\-rliK<p]/{rJ$"X`N{C-/OS-z[*gTm.e+>"
Non-match examples:
- "<img fq3f3/>"
- "<img3/>frf"
Regular expression: <img([^>]*[^/])>
This regular expression is designed to match and validate day numbers within a month, allowing values from 1 to 31. It takes into account single-digit days (1-9), double-digit days (10-29), and specific values for the 30th and 31st days of a month.
Match examples:
- "01"
- "12"
- "31"
Non-match examples:
- "123"
- "32"
Regular expression: ^((0?[1-9])|((1|2)[0-9])|30|31)$
Effectively locate and extract HTML comments from a text or HTML document, including multi-line comments, while being non-greedy to avoid matching comments that span multiple comment blocks.
Match examples:
- "&lt;!-- comments --&gt;"
- "&lt;!-- x = a &gt; b - 3 --&gt;"
- "&lt;!----&gt;"
Non-match examples:
- "&lt;COMMENTS&gt;this is a comment&lt;/COMMENTS&gt;"
- "f34fvfv"
Regular expression: &lt;!--[\s\S]*?--&gt;
Validates a GUID with and without brackets. 8,4,4,4,12 hex characters seperated by dashes.
Match examples:
- "{e02ff0e4-00ad-090A-c030-0d00a0008ba0}"
- "e02ff0e4-00ad-090A-c030-0d00a0008ba0"
- "29BF7EaE-e661-BDcd-deBB-F9097812DFC6}"
Non-match examples:
- "0xe02ff0e400ad090Ac0300d00a0008ba0"
- "f34fvfv"
Regular expression: ^\{?[a-fA-F\d]{8}-([a-fA-F\d]{4}-){3}[a-fA-F\d]{12}\}?$
This regular expression can be used to parse and capture measurements in feet and inches, with optional symbols like apostrophes ('), hyphens (-), and forward slashes (/), as well as the denominator part (e.g., 16) of inches, and it ends with a double quotation mark (").
Match examples:
- "5'-3/16&quot;"
- "1'-2&quot;"
- "5/16&quot;"
Non-match examples:
- "1 3/16"
- "52/2/54/245"
Regular expression: (\d*)'*-*(\d*)/*(\d*)&quot;
This regular expression is used to validate strings that contain a mix of characters, including word characters (alphanumeric and underscores), non-word characters, and any characters that are not among a specific set of special characters often used in HTML and programming. It ensures that the string does not contain the specified special characters.
Match examples:
- "John Doe Sr."
- "100 Elm St., Suite 25"
- "Valerie's Gift Shop"
Non-match examples:
- "<h1>Hey</h1>"
- "<h1>adsfa</h1>"
Regular expression: ^(/w|/W|[^<>+?$%{}&])+$
This regular expressions matches dates in the format MM/YYYY where MM can be 01 to 12 and YYYY is always 4 digits long.
Match examples:
- "12/2002"
- "11/1900"
- "02/1977"
Non-match examples:
- "1/1977"
- "00/000"
Regular expression: ^((0[1-9])|(1[0-2]))\/(\d{4})$
This regular expression pattern matches a string that starts with two uppercase letters, followed by six digits, and ends with one uppercase letter, where the last uppercase letter can be either A, B, C, D, F, or M.
Match examples:
- "AB123456D"
- "AB123456F"
- "AB123456M"
Non-match examples:
- "AB123456E"
- "ab123456d"
Regular expression: ^[A-Z]{2}[0-9]{6}[A-DFM]{1}$
This is a regular expression to validate a date string in &quot;MM/DD/YYYY&quot; format, a date time string in &quot;MM/DD/YYYY HH:MM&quot; or a date time string in &quot;MM/DD/YYYY HH:MM:SS&quot; format.
It can validate date from 1600 to 2199.
Match examples:
- "12/30/2002"
- "01/12/1998 13:30"
- "01/28/2002 22:35:00"
Non-match examples:
- "13/30/2002"
- "01/12/1998 24:30"
Regular expression: ^([0]\d|[1][0-2])\/([0-2]\d|[3][0-1])\/([2][01]|[1][6-9])\d{2}(\s([0-1]\d|[2][0-3])(\:[0-5]\d){1,2})?$
Date validation M/D/YY or M/D/YYYY or MM/DD/YYYY or MM/DD/YY: 1/1/1920 through 12/31/2019; Feb 29 and 30 always allowed.
Match examples:
- "1/2/03"
- "02/30/1999"
- "3/04/00"
Non-match examples:
- "3/4/2020"
- "3/4/1919"
Regular expression: ^((0?[13578]|10|12)(-|\/)(([1-9])|(0[1-9])|([12])([0-9]?)|(3[01]?))(-|\/)((19)([2-9])(\d{1})|(20)([01])(\d{1})|([8901])(\d{1}))|(0?[2469]|11)(-|\/)(([1-9])|(0[1-9])|([12])([0-9]?)|(3[0]?))(-|\/)((19)([2-9])(\d{1})|(20)([01])(\d{1})|([8901])(\d{1})))$
This time validation expression accepts an hour between 1 and 9 (with optional leading zero) and minutes between 01 and 59.
Match examples:
- "09:00"
- "9:00"
- "11:35"
Non-match examples:
- "13:00"
- "9.00"
Regular expression: ^(([0]?[1-9]|1[0-2])(:)([0-5][0-9]))$
Validate 12-hour time with am/pm after it, with optional spaces before or after, and optionally between time and am/pm.
Match examples:
- "12:00am"
- "1:00 PM"
- "12:59 pm"
Non-match examples:
- "0:00"
- "0:01 am"
Regular expression: ^ *(1[0-2]|[1-9]):[0-5][0-9] *(a|p|A|P)(m|M) *$
It matches strings that consist of one or more words, where each word starts with an uppercase letter followed by one or more lowercase letters. The words can be separated by spaces. It also matches an empty string. The expression allows for variations in the number of words, from one to three, each following the same pattern of an initial uppercase letter followed by lowercase letters.
Match examples:
- "Sacramento"
- "San Francisco"
- "San Luis Obispo"
Non-match examples:
- "SanFrancisco"
- "SanLuisObispo"
Regular expression: ^([A-Z]{1}[a-z]{1,})$|^([A-Z]{1}[a-z]{1,}\040[A-Z]{1}[a-z]{1,})$|^([A-Z]{1}[a-z]{1,}\040[A-Z]{1}[a-z]{1,}\040[A-Z]{1}[a-z]{1,})$|^$
Used to validate time values in in MySQL time format, in the format "hh:mm:ss" where hours are in the range of 00-23, minutes and seconds are in the range of 00-59.
Match examples:
- "09:30:00"
- "17:45:20"
- "23:59:59"
Non-match examples:
- "24:00:00"
- "79:987:8"
Regular expression: (([0-1][0-9])|([2][0-3])):([0-5][0-9]):([0-5][0-9])
This regular expression matches two types of time formats:

1. 12-hour clock format (hh:mm AM/PM or hh:mmam/pm):

The hour part can be a 1 or 2-digit number from 1 to 12.
The minute part can be empty or can be 00, 15, 30, or 45.
It can have a space followed by AM or PM (in any case variation) or am or pm (in any case variation).

2. 24-hour clock format (hh:mm):

The hour part can be a 1 or 2-digit number from 00 to 23.
The minute part can be empty or can be 00, 15, 30, or 45.
Match examples:
- "1:00 PM"
- "6:45 am"
- "17:30"
Non-match examples:
- "4:32 am"
- "5:30:00 am"
Regular expression: ^((([0]?[1-9]|1[0-2])(:|\.)(00|15|30|45)?( )?(AM|am|aM|Am|PM|pm|pM|Pm))|(([0]?[0-9]|1[0-9]|2[0-3])(:|\.)(00|15|30|45)?))$
Match examples:
- "-0.050"
- "-5.000"
- "-5"
Non-match examples:
- "0"
- "0.0"
Regular expression: (^-\d*\.?\d*[1-9]+\d*$)|(^-[1-9]+\d*\.\d*$)
Validates numerical values that may use commas for thousands separation and have an optional decimal part. Also matches empty string.
Match examples:
- "1,000"
- "3,000.05"
- "5,000,000"
Non-match examples:
- "abc"
- "$100,000"
Regular expression: ^(\d|,)*\.?\d*$
It validates numeric values, including positive integers with or without a leading plus sign.
Match examples:
- "0123456789"
- "1234"
- "1"
Non-match examples:
- "1.0?&amp;"
- "a1"
Regular expression: ^[+]?\d*$
Regular expression to match valid UK postcodes.
In the UK postal system not all letters are used in all positions (the same with vehicle registration plates) and there are various rules to govern this. This regex takes into account those rules.
Details of the rules:
First half of postcode
Valid formats
[A-Z][A-Z][0-9][A-Z]
[A-Z][A-Z][0-9][0-9]
[A-Z][0-9][0-9]
[A-Z][A-Z][0-9]
[A-Z][A-Z][A-Z]
[A-Z][0-9][A-Z]
[A-Z][0-9]
Exceptions
Position - First.
Contraint - QVX not used
Position - Second.
Contraint - IJZ not used except in GIR 0AA
Position - Third.
Constraint - AEHMNPRTVXY only used
Position - Forth.
Contraint - ABEHMNPRVWXY
Second half of postcode
Valid formats
[0-9][A-Z][A-Z]
Exceptions
Position - Second and Third.
Contraint - CIKMOV not used
Match examples:
- "DN3 6GB"
- "SW42 4RG"
- "GIR 0AA"
Non-match examples:
- "SEW4 5TY"
- "AA2C 4FG"
Regular expression: ^([A-PR-UWYZ0-9][A-HK-Y0-9][AEHMNPRTVXY0-9]?[ABEHMNPRVWXY0-9]? {1,2}[0-9][ABD-HJLN-UW-Z]{2}|GIR 0AA)$
Accepts data of time in format h:mm and hh:mm
Match examples:
- "0:00"
- "23:00"
- "00:59"
Non-match examples:
- "0:0"
- "24:00"
Regular expression: ^([0-1]?[0-9]|[2][0-3]):([0-5][0-9])$
Validates MM/YY for rough checking credit card expiration dates.
Match examples:
- "11/03"
- "01/04"
- "09/39"
Non-match examples:
- "13/03"
- "10/2003"
Regular expression: ^((0[1-9])|(1[0-2]))\/(\d{2})$
This regex is to validate the time of a ~60 minute CD where the most time on the CD is 59:59 (minutes:seconds).
Match examples:
- "30:05"
- "5:05"
- "02:59"
Non-match examples:
- "25:7"
- "5m:16"
Regular expression: ^(([0]?[0-5][0-9]|[0-9]):([0-5][0-9]))$
In summary, this regular expression matches strings that start with a dollar sign, followed by a group of one to three digits, optionally followed by a comma, optionally followed by a group of three digits, optionally followed by a decimal point and one to three digits, or a group of one to three digits followed by an optional decimal point and two digits.
Match examples:
- "10000"
- "10,000"
- "$1,000.00"
Non-match examples:
- "0.002"
- "x.0"
Regular expression: ^\$?(\d{1,3},?(\d{3},?)*\d{3}(\.\d{1,3})?|\d{1,3}(\.\d{2})?)$
Matches a six character &quot;password&quot; that has to consist of numbers and letters with at least one letter in it.
Match examples:
- "123a12"
- "a12345"
- "aaaaaa"
Non-match examples:
- "111111"
- "123456"
Regular expression: ^(?![0-9]{6})[0-9a-zA-Z]{6}$
This regular expression matches 10 digit US Phone numbers in different formats. Some examples are
1)area code in paranthesis.
2)space between different parts of the phone number.
3)no space between different parts of the number.
4)dashes between parts.
Match examples:
- "(573)8841878"
- "573-884-1234"
- "573 234 1256"
Non-match examples:
- "(573)(673)2345"
- "573-12-2345"
Regular expression: ^\(?[\d]{3}\)?[\s-]?[\d]{3}[\s-]?[\d]{4}$
Checks if has the first and the last name, and check the capital letters.
Match examples:
- "Carlos Rodrigues"
- "Cá de Laaa"
- "Crras R. L. Rodrigües"
Non-match examples:
- "aaäA"
- "E:\DyAGT\SD01A_specV2.jpg"
Regular expression: (^[A-ZÀ-Ü]{1}[a-zà-ü']+\s[a-zA-Zà-üÀ-Ü]+((([\s\.'])|([a-zà-ü']+))|[a-zà-ü']+[a-zA-Zà-üÀ-Ü']+))
dd/mm/yy
Check dates between 1/1/1900 - 31/12/2099
Match examples:
- "31/12/2099"
- "1/1/1900"
- "10/12/2003"
Non-match examples:
- "05/11/3000"
- "11/13/2003"
Regular expression: (^((((0[1-9])|([1-2][0-9])|(3[0-1]))|([1-9]))\x2F(((0[1-9])|(1[0-2]))|([1-9]))\x2F(([0-9]{2})|(((19)|([2]([0]{1})))([0-9]{2}))))$)
Dutch postal code expression. 4 digits followed by max. two spaces end ending on two letters.
Match examples:
- "4006 AB"
- "4006ab"
- "4006 AB"
Non-match examples:
- "4006.ab"
- "4006_ab"
Regular expression: ^[0-9]{4}\s{0,2}[a-zA-z]{2}$
Validates US phone numbers. Phone number can be delimited with dashes or spaces. Area code can optionally include parentheses.
Match examples:
- "(111) 223-2332"
- "(222)233-2332"
- "232-323-3233"
Non-match examples:
- "(ddd) 223-2332"
- "222-232/2333"
Regular expression: ^([\(]{1}[0-9]{3}[\)]{1}[ |\-]{0,1}|^[0-9]{3}[\-| ])?[0-9]{3}(\-| ){1}[0-9]{4}$
Correct German DateTime. Does not check leap year rules!
Possible Formats of date part:
D.M.YYYY or D.MM.YYYY or DD.MM.YYYY or DD.M.YYYY
Possible formats of time part:
h:mm or hh:mm
Match examples:
- "20.10.2003 08:10"
- "24.12.2003"
- "1.1.2004 8:15"
Non-match examples:
- "25.13.2004"
- "20.10.2003 08:9"
Regular expression: ^(([1-9]|[0-2]\d|[3][0-1])\.([1-9]|[0]\d|[1][0-2])\.[2][0]\d{2})$|^(([1-9]|[0-2]\d|[3][0-1])\.([1-9]|[0]\d|[1][0-2])\.[2][0]\d{2}\s([1-9]|[0-1]\d|[2][0-3])\:[0-5]\d)$
This regular expressions matches CNPJ number. CNPJ is a Registration Number of Brazilian Companies.
Match examples:
- "00.000.000/0000-00"
- "00000000000000"
- "657552683148-18"
Non-match examples:
- "00-000-000-000-00"
- "AA.AAA.AAA/AAAA-AA"
Regular expression: \d{2}.?\d{3}.?\d{3}/?\d{4}-?\d{2}
Date expression validator with format YYMMDD, validates leap years. As year has only 2 digits, it's not possible to invalidate years like 2100, 2200, 2300, etc as a non-leap years.
Match examples:
- "751231"
- "000229"
- "040229"
Non-match examples:
- "750431"
- "010229"
Regular expression: ^((\d{2}((0[13578]|1[02])(0[1-9]|[12]\d|3[01])|(0[13456789]|1[012])(0[1-9]|[12]\d|30)|02(0[1-9]|1\d|2[0-8])))|([02468][048]|[13579][26])0229)$
Email address validator. Should cover most of RFC 822, including unusual (but still valid) addresses. Does not restrict the top level domain size, but you're better off doing an nslookup or similar if you absolutely must have a valid domain. Accepts IP Addresses instead of the domain, with or without brackets. Believe it or not, this one is valid: !#$%^&amp;amp;amp;amp;*-+~/'`|{}@xyz.com
Match examples:
- "/A/Wacky/User@weirdos.com"
- "bob.builder@[1.1.1.1]"
- ""blah b. blahburger"@blah.com"
Non-match examples:
- "./A/Wacky/User@weirdos.com"
- "bob.builder@[256.1.1.1]"
Regular expression: ^((\"[^\"\f\n\r\t\v\b]+\")|([\w\!\#\$\%\&\'\*\+\-\~\/\^\`\|\{\}]+(\.[\w\!\#\$\%\&\'\*\+\-\~\/\^\`\|\{\}]+)*))@((\[(((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9])))\])|(((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9])))|((([A-Za-z0-9\-])+\.)+[A-Za-z\-]+))$
Input for Numeric values. Handles negatives, and comma formatted values. Also handles a single decimal point
Match examples:
- "5,000"
- "-5,000"
- "100.044"
Non-match examples:
- "abc"
- "Hundred"
Regular expression: ^(\d|-)?(\d|,)*\.?\d*$
^[1-9]+[0-9]*$
Match examples:
- "1"
- "12"
- "124"
Non-match examples:
- "-1"
- "a"
Regular expression: ^[1-9]+[0-9]*$
Matches strings that start with one or more groups of lowercase letters followed by a dot and end with an uppercase letter followed by one or more lowercase letters. This matches Java class names such as &quot;com.test.Test&quot;. It's being used within an XML Schema to validate classname as specified in XML documents.
Match examples:
- "com.test.Test"
- "com.Test"
- "afd.Tds"
Non-match examples:
- "com.test.test"
- "com.test.TEst"
Regular expression: ^(([a-z])+.)+[A-Z]([a-z])+$
Matches variable names/identifier from C# (and most other languages). This regular expression ensures that a string:

Starts with a letter (either uppercase or lowercase) or an underscore.
Followed by zero or more letters (uppercase or lowercase), digits, or underscores.
Enforces these rules for the entire string, not just a part of it.
Match examples:
- "VariableName"
- "i"
- "Some_Value_3"
Non-match examples:
- "3ID"
- "Hello World"
Regular expression: ^[a-zA-Z_][a-zA-Z0-9_]*$
Credit card validator for AMEX, VISA, MasterCard only. Allows spaces, dashes, or no separator between digit groups according to the layout (4-6-5 for AMEX, 4-4-4-4 for Visa and Mastercard)
Match examples:
- "3711-078176-01234"
- "4123 5123 6123 7123"
- "5123412361237123"
Non-match examples:
- "3711-4123-5123-6112"
- "52/2/54/245"
Regular expression: ^((4\d{3})|(5[1-5]\d{2}))(-?|\040?)(\d{4}(-?|\040?)){3}|^(3[4,7]\d{2})(-?|\040?)\d{6}(-?|\040?)\d{5}
This allows a sequence of real numbers to be added, separated by a comma (required) and a space (optional).
Match examples:
- "8.0"
- "8.0,-.38,+8.9"
- "8.0, +8.8, 0.09"
Non-match examples:
- "+"
- "."
Regular expression: ^((\d?)|(([-+]?\d+\.?\d*)|([-+]?\d*\.?\d+))|(([-+]?\d+\.?\d*\,\ ?)*([-+]?\d+\.?\d*))|(([-+]?\d*\.?\d+\,\ ?)*([-+]?\d*\.?\d+))|(([-+]?\d+\.?\d*\,\ ?)*([-+]?\d*\.?\d+))|(([-+]?\d*\.?\d+\,\ ?)*([-+]?\d+\.?\d*)))$
Matches strings containing up to 16 characters, including newline characters. It allows any combination of characters and newlines within this limit.
Match examples:
- "shorter than max"
- "sgfdij"
- "jiodfk90"
Non-match examples:
- "string longer than max"
- "9uionjy89ubih8bhuk78byu"
Regular expression: ^(.|\n){0,16}$
Matches filenames that follow the pattern of a Windows file path, consisting of a drive letter, a path within the drive, and a file extension.
Match examples:
- "C:\di___r\fi_sysle.txt"
- "c:\dir\filename.txt"
- "d:\dir\fads.abc"
Non-match examples:
- "c:\dir\file?name.txt"
- "c:\f34fvfv"
Regular expression: ^([a-zA-Z]\:)(\\[^\\/:*?<>"|]*(?<![ ]))*(\.[a-zA-Z]{2,6})$
Match and validate time in a 24-hour format (hh:mm). It allows for hours ranging from 0 to 23 and minutes ranging from 00 to 59. The colon (":") between hours and minutes is optional, and the regex ensures that the input conforms to this specific time format.
Match examples:
- "0959"
- "959"
- "9:59"
Non-match examples:
- "90"
- "960"
Regular expression: ^(([0-9])|([0-1][0-9])|([2][0-3])):?([0-5][0-9])$
Match and validate a specific pattern within a string:

It starts with a "0."
Followed by a pattern that consists of "6" followed by one character from the set [045679], followed by another character from the set [0469]. This pattern occurs exactly once.
There is an optional hyphen ("-").
There is an optional "1."
Followed by a single character that is not "0" or a non-digit character.
Ends with six digits.
Match examples:
- "0664-1234567"
- "06641234567"
- "0699-11234567"
Non-match examples:
- "06991-1234567"
- "+43650-1234567"
Regular expression: ^0(6[045679][0469]){1}(\-)?(1)?[^0\D]{1}\d{6}$
Matches a whole number between 1 and 20 inclusively
Match examples:
- "1"
- "11"
- "20"
Non-match examples:
- "0"
- "21"
Regular expression: ^1?[1-9]$|^[1-2]0$
Validates Dutch Postal Codes (ZipCode).
Match examples:
- "1234AB"
- "1234 AB"
- "1001 AB"
Non-match examples:
- "0123AB"
- "1234A B"
Regular expression: ^[1-9][0-9]{3}\s?[a-zA-Z]{2}$
Accept only (0-9) integer and one decimal point(decimal point is also optional).After decimal point it accepts at least one numeric .This will be usefull in money related
fields or decimal fields.
Match examples:
- ".568"
- "8578"
- "1234567.1234567"
Non-match examples:
- "568."
- "56.89.36"
Regular expression: ^([0-9]*|\d*\.\d{1}?\d*)$
DateTime Validator. 

Date Validation:

Validates dates in various formats (e.g., DD/MM/YYYY, DD-MM-YYYY, DD.MM.YYYY).
Supports both leap years and non-leap years.
Ensures valid months (1-12) and days (1-31) based on the selected month.
Validates year ranges from 1600 to 9999.
Time Validation:

Validates time in 12-hour or 24-hour format.
Supports optional seconds.
Validates hours (1-12 in AM/PM format or 0-23 in 24-hour format) and minutes (0-59).
Match examples:
- "12/25/2003"
- "08:03:31"
- "02/29/2004 12 AM"
Non-match examples:
- "02/29/2003 1:34 PM"
- "13:23 PM"
Regular expression: ^(?=\d)(?:(?:(?:(?:(?:0?[13578]|1[02])(\/|-|\.)31)\1|(?:(?:0?[1,3-9]|1[0-2])(\/|-|\.)(?:29|30)\2))(?:(?:1[6-9]|[2-9]\d)?\d{2})|(?:0?2(\/|-|\.)29\3(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))|(?:(?:0?[1-9])|(?:1[0-2]))(\/|-|\.)(?:0?[1-9]|1\d|2[0-8])\4(?:(?:1[6-9]|[2-9]\d)?\d{2}))($|\ (?=\d)))?(((0?[1-9]|1[012])(:[0-5]\d){0,2}(\ [AP]M))|([01]\d|2[0-3])(:[0-5]\d){1,2})?$
Validates time input in either 12-hour (with AM/PM) or 24-hour formats, allowing for optional minutes and seconds.
Match examples:
- "1 AM"
- "23:00:00"
- "5:29:59 PM"
Non-match examples:
- "13 PM"
- "13:60:00"
Regular expression: ^((0?[1-9]|1[012])(:[0-5]\d){0,2}(\ [AP]M))$|^([01]\d|2[0-3])(:[0-5]\d){0,2}$
Matches HTML Color strings.
Match examples:
- "#FFFFFF"
- "#FF3421"
- "#00FF00"
Non-match examples:
- "232323"
- "f#fddee"
Regular expression: ^(#){1}([a-fA-F0-9]){6}$