expression
stringlengths 4
1.37k
| raw_prompt
stringlengths 11
1.08k
| refined_prompt
stringlengths 79
906
| matches
sequence | non_matches
sequence | id
int64 1
4.11k
|
|---|---|---|---|---|---|
^([0-1]?[0-9]|[2][0-3]):([0-5][0-9])$ | Checks time in 24 hours notation, however this one is shorter than the ones I found on regexplib | Checks time in 24 hours notation
Match examples:
- "23:00"
- "12:21"
- "0:00"
Non-match examples:
- "24:00"
- "23:60" | [
"23:00",
"12:21",
"0:00",
"07:21",
"23:07",
"4:53",
"21:05",
"8:33",
"20:14",
"23:53",
"2:20",
"20:42",
"3:44"
] | [
"24:00",
"23:60",
"0:60",
"-123",
"234",
"$23.454",
"43-5432",
"254627g.256",
"000-000",
"76:r4",
"74:54",
"86:34"
] | 1,468 |
^([0-1]?[0-9]{1}/[0-3]?[0-9]{1}/20[0-9]{2})$ | This regular expression will validate most (current & future) date options. The weaknesses with this one is that it will allow the days to go up to 39 and does not account for leap year. Also, the months can go up to 19, instead of our commonly accepted 12 month year. :) I designed this expression to validate dates from the year 2000 to 2099. I do not plan on this same code being in place in 2099, so I hope this is sufficient enough... | This regular expression will validate most (current & future) date options. The weaknesses with this one is that it will allow the days to go up to 39 and does not account for leap year. Also, the months can go up to 19, instead of our commonly accepted 12 month year.
Match examples:
- "2/14/2001"
- "12/29/2099"
- "19/39/2000"
Non-match examples:
- "12/29/1999"
- "20/40/2100" | [
"2/14/2001",
"12/29/2099",
"19/39/2000",
"4/5/2089",
"8/27/2010",
"11/7/2058",
"6/12/2084",
"13/24/2016",
"7/18/2077",
"6/5/2055",
"16/03/2054",
"2/14/2082",
"03/2/2096"
] | [
"12/29/1999",
"20/40/2100",
"2534/52435234/2453",
"(12) 324 653210",
"234/423/5243",
"$23.454",
"43-5432",
"254627g.256",
"245/524/12",
"897-",
"34.31",
"3409fjg43"
] | 1,484 |
^\d+\*\d+\*\d+$ | one or more numbers, asterisk, one or more numbers, asterisk, one or more numbers, no letters or punctuation other than asterisks. | one or more numbers, asterisk, one or more numbers, asterisk, one or more numbers, no letters or punctuation other than asterisks.
Match examples:
- "123*4578*8908650"
- "14*523*154"
- "14*4*5432"
Non-match examples:
- "12a*99989*9096"
- "52/2/5*4/82*45" | [
"123*4578*8908650",
"14*523*154",
"14*4*5432",
"1*523*5432",
"641*523*5432",
"14*523*6544",
"14*4351*5432",
"14*3416*5432",
"1463136*523*5432",
"14*523*416",
"8766*523*5432",
"14*654*5432",
"14*523*2346"
] | [
"12a*99989*9096",
"52/2/5*4/82*45",
"2534/52*4835234*/2453",
"(12) 3*248 6*53210",
"23*4/8423/5*243",
"3n8*f@*",
"43*-58432*",
"2*54627g.2*68",
"245/52*4/12",
"354/*243/542",
"(0xx12) 62*509@",
"34*09fjg43"
] | 1,485 |
^100(\.0{0,2}?)?$|^\d{0,2}(\.\d{0,2})?$ | Matches percentages from 0-100 inclusive with two decimal places. | Matches percentages from 0-100 inclusive with two decimal places.
Match examples:
- "0"
- "100"
- "100.00"
Non-match examples:
- "101"
- "-5" | [
"0",
"100",
"100.00",
"45.45",
"74",
"86",
"85",
"35.35",
"99",
"65",
"66.66",
"44.46",
"83.73"
] | [
"101",
"-5",
"45.456",
"-123",
"51:534",
"$23.454",
"43-5432",
"1.12423",
"9516-9516",
"354/243/542",
"34.3125",
"32542"
] | 1,489 |
^((0[1-9])|(1[0-2]))\/((0[1-9])|(1[0-9])|(2[0-9])|(3[0-1]))\/(\d{4})$ | This regular expressions matches dates in the format MM/DD/YYYY where MM can be 01 to 12, DD can be 01 to 31 and YYYY is always 4 digits long. | This regular expressions matches dates in the format MM/DD/YYYY where MM can be 01 to 12, DD can be 01 to 31 and YYYY is always 4 digits long.
Match examples:
- "12/25/2007"
- "11/07/1517"
- "02/25/2727"
Non-match examples:
- "1/27/1977"
- "00/01/000" | [
"12/25/2007",
"11/07/1517",
"02/25/2727",
"01/31/1026",
"01/02/1770",
"12/30/5833",
"12/09/6504",
"07/18/0292",
"11/31/7444",
"05/09/9524",
"09/31/6773",
"12/28/5047",
"11/30/1576"
] | [
"1/27/1977",
"00/01/000",
"15/07/2002",
"(12) 324 653210",
"234/423/5243",
"$23.454",
"43-5432",
"254627g.256",
"245/524/12",
"354/243/542",
"9/9/9",
"3409fjg43"
] | 1,492 |
[0-9]{4}-([0][0-9]|[1][0-2])-([0][0-9]|[1][0-9]|[2][0-9]|[3][0-1]) | This function does basic testing for the YYYY-MM-DD date format. | This function does basic testing for the YYYY-MM-DD date format.
Match examples:
- "1981-10-16"
- "6401-04-30"
- "3202-11-05"
Non-match examples:
- "1981-13-10"
- "52/2/-54/2-45" | [
"1981-10-16",
"6401-04-30",
"3202-11-05",
"7024-05-13",
"2690-11-05",
"6492-12-11",
"6280-10-10",
"4225-09-25",
"5745-11-17",
"0117-08-21",
"6780-10-31",
"0337-07-31",
"2116-12-08"
] | [
"1981-13-10",
"52/2/-54/2-45",
"2534/5243-5234/2-453",
"(12) 32-4 653210",
"234/423/5-243",
"$2-3.454",
"43-5-432",
"2546-27g.256",
"245/52-4/12",
"354/2-43/542",
"(0xx12-) 62509@",
"++6345-3.345"
] | 1,495 |
^(((19|20)(([0][48])|([2468][048])|([13579][26]))|2000)[\-](([0][13578]|[1][02])[\-]([012][0-9]|[3][01])|([0][469]|11)[\-]([012][0-9]|30)|02[\-]([012][0-9]))|((19|20)(([02468][1235679])|([13579][01345789]))|1900)[\-](([0][13578]|[1][02])[\-]([012][0-9]|[3][01])|([0][469]|11)[\-]([012][0-9]|30)|02[\-]([012][0-8])))$ | This regex match dates in the international standard date notation by ISO (IS0 8601). It can validate any dates between 1900-01-01 and 2099-12-31 ant take account of leap years. The format is mandatory and the hyphen is needed. You could easily change it to accept other separators. It has been tested with Regex Coach and PHP. | This regex match dates in the international standard date notation by ISO (IS0 8601). It can validate any dates between 1900-01-01 and 2099-12-31 ant take account of leap years. The format is mandatory and the hyphen is needed.
Match examples:
- "1900-01-01"
- "2099-12-31"
- "2004-02-29"
Non-match examples:
- "20060526"
- "1900-02-29" | [
"1900-01-01",
"2099-12-31",
"2004-02-29",
"1900-11-25",
"2000-11-30",
"1909-12-28",
"2000-06-30",
"2007-09-30",
"2089-11-20",
"2000-04-11",
"1900-12-31",
"1900-12-24",
"2052-12-30"
] | [
"20060526",
"1900-02-29",
"2100-01-01",
"(12) 324 653210",
"234/423/5243",
"$23.454",
"43-5432",
"254627g.256",
"245/524/12",
"354/243/542",
"(0xx12) 62509@",
"++63453.345"
] | 1,512 |
^(-?)(((\d{1,3})(,\d{3})*)|(\d+))(\.\d{1,2})?$ | This RegEx checks whether the input is a number or not. Number may contain commas a seperators, can contain one or two decimal places and can be positive or negative. | This RegEx checks whether the input is a number or not. Number may contain commas a seperators, can contain one or two decimal places and can be positive or negative.
Match examples:
- "100,000,000.00"
- "-100,000,000.00"
- "100,000,000"
Non-match examples:
- "100,000,00.00"
- "1000.000" | [
"100,000,000.00",
"-100,000,000.00",
"100,000,000",
"-100,000,000",
"100000000.00",
"-100000000.00",
"100000000",
"-100000000",
"1534",
"4352",
"635",
"87436",
"243"
] | [
"100,000,00.00",
"1000.000",
"1000.",
"(12) 324 653210",
"234/423/5243",
"$23.454",
"43-5432",
"254627g.256",
"245/524/12",
"354/243/542",
"(0xx12) 62509@",
"3409fjg43"
] | 1,515 |
^1?[1-2]$|^[1-9]$|^[1]0$ | Get one and two numeric digits between 1 and 12 inclusive, positive numbers only (Zeros are excluded and so is values higher than 12). | Get one and two numeric digits between 1 and 12 inclusive, positive numbers only (Zeros are excluded and so is values higher than 12).
Match examples:
- "1"
- "6"
- "12"
Non-match examples:
- "-1"
- "0" | [
"1",
"6",
"12",
"2",
"3",
"4",
"5",
"7",
"8",
"9",
"10",
"11"
] | [
"-1",
"0",
"13",
"4312",
"45",
"65",
"6f",
"567",
"7654",
"2c",
"5647",
"43c"
] | 1,520 |
^N[1-9][0-9]{0,4}$|^N[1-9][0-9]{0,3}[A-Z]$|^N[1-9][0-9]{0,2}[A-Z]{2}$ | FAA Tail Numbers as described here: http://www.faa.gov/licenses_certificates/aircraft_certification/aircraft_registry/special_nnumbers/ | FAA Tail Numbers
Match examples:
- "N12345"
- "N52T"
- "N84WE"
Non-match examples:
- "N123456"
- "Nh9if23" | [
"N12345",
"N52T",
"N84WE",
"N68",
"N423A",
"N6NY",
"N2242",
"N28KJ",
"N35",
"N30C",
"N4193",
"N2CA",
"N19NM"
] | [
"N123456",
"Nh9if23",
"N34f2vf42e",
"N12/123/4322",
"N123.456.789",
"N123.456.7890",
"N56.153153",
"N/5/5/20022",
"N432/524/2435",
"Nadfa2",
"N(0xx12) 62509",
"N12/132/90"
] | 1,539 |
\d\d?\d?\.\d\d?\d?\.\d\d?\d?\.\d\d?\d? | Quick and simple way of matching a well-formed IPV4 (dotted quad) ip address. | Quick and simple way of matching a well-formed IPV4 (dotted quad) ip address.
Match examples:
- "192.168.1.19"
- "6.3.948.89"
- "28.38.1.25"
Non-match examples:
- "19x.168.1.19"
- "f34fvfv" | [
"192.168.1.19",
"6.3.948.89",
"28.38.1.25",
"4.6.75.1",
"3.11.38.1",
"2.62.64.19",
"11.186.9.74",
"167.0.2.095",
"1.18.615.26",
"7.502.83.9",
"10.890.4.90",
"5.62.836.51",
"72.62.38.143"
] | [
"19x.168.1.19",
"f34fvfv",
"34f2vf42e",
"12/123/4322",
"2346-2345-2435",
"43.v234",
"@#dfkjnav",
"/5/5/20022",
"432/524/2435",
"341.431v4f3.fv1",
"(0xx12) 62509",
"12/132/90"
] | 1,549 |
^\d*[0-9](\.\d?[0-9])?$ | Allow Decimal values as [decimal](*, 2), scale length between 0 and 2 | Allow Decimal values as [decimal](*, 2), scale length between 0 and 2
Match examples:
- "87645.09"
- "87645.9"
- "87645.10"
Non-match examples:
- "87645.091"
- "87645." | [
"87645.09",
"87645.9",
"87645.10",
"87645",
"777698353094752880760794069684108698341032758279235997847364392067648258518127050.5",
"6077107689090387339015186298602908029420195008990703295970503721211509552189837978",
"62534419400374094193",
"7847110062233216866380559814689829460556814730990738759420596.7",
"6388755307341136274141229227906518971513195109976980738120192063260.5",
"920273193897792617989888255137588685406964083175.0",
"8421404992436294109084605391115890355156252405827714599269051017476507953982066470036296406989",
"40.4",
"2661675356454810967369157361635808125799434042000783742662896962"
] | [
"87645.091",
"87645.",
"werfvd",
"3er4t5grevds",
"ddwe4rt5y67u6y54",
"#333",
"$567",
"5643%",
"number",
".0",
"3r4efd",
"2343ss"
] | 1,566 |
^((\d{0,1}[0-9](\.\d{0,1}[0-9])?)|(100))$ | Allow Percentage with optional scale (max length of 2) between (00.00 and 100) | Captures percentage with 0-2 decimal points (00.00 - 100).
Match examples:
- "00.00"
- "00"
- "99.99"
Non-match examples:
- "99."
- "100.1" | [
"00.00",
"00",
"99.99",
"99.5",
"100",
"1",
"12.0",
"0.5",
"0.75",
"0.20",
"0.01",
"00.99",
"00.15"
] | [
"99.",
"100.1",
"0.",
".0",
"101",
"-1",
"+4",
"5%",
"00.003",
"3.1415",
"555.555",
"1000"
] | 1,567 |
^([0-9]{4})-([0-1][0-9])-([0-3][0-9])\s([0-1][0-9]|[2][0-3]):([0-5][0-9]):([0-5][0-9])$ | SQL datetime format tester YYYY-MM-DD HH:MM:SS | Structured query language (SQL) date and time format. In the format: YYYY-MM-DD HH:MM:SS (YEAR-MONTH-DAY HOUR-MINUTE-SECOND). Accepts some logically invalid months and date configurations.
Match examples:
- "2007-07-01 01:01:01"
- "2007-08-04 18:01:01"
- "2003-01-26 09:26:01"
Non-match examples:
- "2007-07-01"
- "2007/07/01" | [
"2007-07-01 01:01:01",
"2007-08-04 18:01:01",
"2003-01-26 09:26:01",
"0000-00-00 00:00:00",
"9999-19-23 00:00:00",
"9009-06-23 23:00:00",
"1111-19-35 23:59:59",
"0000-00-00 00:00:01",
"0405-06-07 08:09:10",
"0788-14-39 22:23:49",
"0334-15-35 10:56:07",
"0420-05-05 20:15:07",
"9599-15-28 22:16:29"
] | [
"2007-07-01",
"2007/07/01",
"2007-08-04 24:00:00",
"2007/07/01 12:12",
"23/4/26",
"8/1/03",
"24:00:33",
"23-01 12:12",
"11:11",
"9-21 00:00",
"2023/08/03 12:34",
"22:16:29 0420-05-05"
] | 1,570 |
(^[0][.]{1}[0-9]{0,}[1-9]+[0-9]{0,}$)|(^[1-9]+[0-9]{0,}[.]?[0-9]{0,}$) | This pattern will match any positive number(Real or Integer). It will not match ZERO or any variation of zero (ie 0.00) | This will capture any unsigned, positive number (real or integer), except any variation of 0 (0, 0.0, 00).
Match examples:
- "0.003"
- "34"
- "6.000"
Non-match examples:
- "0.0"
- "-34" | [
"0.003",
"34",
"6.000",
"7.3",
"123456789",
"3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280",
"0.5",
"6.700000000000038854387",
"0.30",
"348739.2384729",
"1.0000",
"10000000000000",
"99.99"
] | [
"0.0",
"-34",
"-23.00",
"0",
"-0.30",
"+6",
".0",
"00000.5",
"0.",
"-00.00",
"+6.57",
"0.000"
] | 1,579 |
([0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})$ | This pattern validates email address. it allows (1)numeric characters and underscore(_) in an address.(2)numeric characters in domain name. it doesn't match user names with a dot(.). doesn;t allow username starting or ending with @ underscore. | The pattern recognizes an email address with the following rules: (1) underscores, periods, and numbers are allowed in usernames, (2) numbers are allowed in the domain name, but not the top-level domain name (before the . but not after), (3) usernames can not start with an underscore or ampersand.
Match examples:
- "san_z@asg.com"
- "xy_z@123g.co.in"
- "san@ss.com.in"
Non-match examples:
- "ssaa_s@asg.c"
- "a@a.com" | [
"san_z@asg.com",
"xy_z@123g.co.in",
"san@ss.com.in",
"asmith@nd.edu",
"333_4@44.com",
"john.doe@et.org",
"billy_d37@uofa.gmail",
"5555@555.555.org",
"the@quick.brown.fox.jumped.over",
"4@54.com",
"54@ttttttt.com",
"999999@999999.oo",
"amazon.com@walmart.org"
] | [
"ssaa_s@asg.c",
"a@a.com",
"san@s.co.in",
"san@apr.com.in.i",
"5.5@5.org",
"joan.anne@school.5",
".org",
"@gmail.org",
"jordan@55",
"66.@path.com",
"<hello>@college.org",
"*&^%@row.edu"
] | 1,585 |
"[^"]+" | Finds strings enclosed in double quotations | Finds strings of characters enclosed in double quotations
Match examples:
- ""MatchingText""
- ""enclosed""
- ""2023""
Non-match examples:
- "NonMatchingText"
- "NoQuotes" | [
"\"MatchingText\"",
"\"enclosed\"",
"\"2023\"",
"\"@gmail.com\"",
"\" \"",
"\" 1234\"",
"\"\\n\"",
"\"1234 E. Apple St.\"",
"\"~\"",
"\"[ ]\"",
"\" @ \"",
"\"HELLO!\"",
"\"https://www.amazon.com/\""
] | [
"NonMatchingText",
"NoQuotes",
"\"NoEnding",
"NoBeginning\"",
"\"\"DoubleBeginning",
"DoubleEnding\"\"",
"'Apostrophe'",
"'BeginningApostrophe",
"EndingApostrophe'",
"\"SwitchedBack'",
"'SwitchedFront\"",
"''DoubleApostrophe''"
] | 1,587 |
(15(8[48]|9[26]))|((1[6-9]|[2-9]\d)(0[48]|[13579][26]|[2468][048]))|(([2468][048]|16|3579[26])00) | Validates four-digit leap years after 1582 (when Pope Gregory XIII switched to the Gregorian calendar). The last recognized leap year is 9996, so no worries with the y3k bug. | Validates four-digit leap years after 1582 (when Pope Gregory XIII switched to the Gregorian calendar). The last recognized leap year is 9996.
Match examples:
- "1584"
- "2000"
- "2048"
Non-match examples:
- "1200"
- "1580" | [
"1584",
"2000",
"2048",
"1588",
"7256",
"1592",
"8396",
"1864",
"1600",
"6000",
"7408",
"2400",
"8000"
] | [
"1200",
"1580",
"1941",
"1800",
"1004",
"001",
"45",
"1408",
"1068",
"1128",
"1324",
"1276"
] | 1,588 |
^[-+]?\d+(\.\d{2})?$ | It accepts only two integer after a decimal point. The number may be in Positive or negative. | Accepts positive or negative integer values. If there is a decimal point, there must be exactly two decimal places given.
Match examples:
- "+1212.14"
- "-12.13"
- "122.45"
Non-match examples:
- "1212.4564"
- "-11.5858" | [
"+1212.14",
"-12.13",
"122.45",
"-0.44",
"+0000444444.44",
"-726.00",
"555",
"99999999999.99",
"0.00",
"1234.12",
"05.05",
"-00.00",
"+9.99"
] | [
"1212.4564",
"-11.5858",
"12.000",
"0.",
"1234.1234",
"+.",
"00-",
"0.9",
"0.999999999999999999",
"+3.14159265359",
"-+0.99",
"-.00"
] | 1,592 |
^(http\:\/\/[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(?:\/\S*)?(?:[a-zA-Z0-9_])+\.(?:jpg|jpeg|gif|png))$ | A nice little regex to verify a URL pointing towards an image. Can be useful. | Verifies that a URL refers to / points towards an image.
Match examples:
- "http://website.com/directory/image.gif"
- "http://mY.16wkdchY-wuvoWpHtZLM5EBD.DqaJ.jpg"
- "http://16dBsg-wTS6wIVjMilL7ILvx.EI5K5BQnEvqd8uxjrYXjmlF6QJpkw.png"
Non-match examples:
- "www.website.com/image.php"
- "www.picture.here" | [
"http://website.com/directory/image.gif",
"http://mY.16wkdchY-wuvoWpHtZLM5EBD.DqaJ.jpg",
"http://16dBsg-wTS6wIVjMilL7ILvx.EI5K5BQnEvqd8uxjrYXjmlF6QJpkw.png",
"http://EjrLECfHkL5.tFopXJ10TkCh-jNjEfiG5e3DdBgreymwuNS5P5pi.aOY2rdWHs6VsEggY7tkn39soXL-wg-diW2yqJEmdMVeg.wFs6F8BHU6z4meVEmCgUUIFs3.jpeg",
"http://8ohZ-LNRwkriF5X7wyh1sqrjaz.vVDt_RAxaZ_Y.jpg",
"http://g35tMNQ-2Ugka1.fPWwpeDcUmj5ZyYbfq6cJcryOBnQI88a7nafgWyzM8WgIT3.gif",
"http://.FklkEJy..eL0teNhL2VFWKFPhaLxqOkZCie5pKS3jfMdwMeNK1r9PeWi6CrzKYq.hIX0J.jpeg",
"http://BWII3EHWgISrvBpTO4u5Fy.UX2mgg_mSSU5e.gif",
"http://hXazX0.RAZcjO0dwlSKFZADxc0NQMzTLycPaVDXmbbeue2f7ETFnMjiR8FwhDTYm8jfQXQswGwn_mTsh2xRx_udPiODC38AaAFwS4.jpg",
"http://JHgb.5lbZEkDbEKGHX5ip2.qVMoegDGIubh5tZDa_YYGtgghkSS0CCGp4mzXcVQ.jpg",
"http://zIu3Ac9Nsu3An6iu01m8.aa.eHtjYgGele9wKP0IybjWen6Rj57560ZiHijaRoalY5oQ66YRAWPo6BSaRRuE76dmh1xVyS0uOkljZMJ_.png",
"http://EGeSMV5M1YtMaqb.LbNmMVe_l4bqoRKHJfOM0gbEWTz.jpeg",
"http://uMO8ePamOatXwcszK.WiO/CeY2}nQ@?nooQr,'SSeDrBL}Wf\\PP'X!1.jpeg"
] | [
"www.website.com/image.php",
"www.picture.here",
"www://Fe96Z8k4hlTowt7QGupJ9lrjp.vCgIyi6cHMvOYQhU_X6kF10HfgOnBXM.png",
"www://BB5Qt93T7992YcRnXw0-uqSwFPjDDxsnyz3-RPaj8KVavqfNbOrkO3g.tvEAI.sSH88ySka3.png",
"www://qrMhM-x-efXsioq2BGCUsS2-6fcYefuK92yoVNjF4sx6YxtyfcMYcKXAoY3tBRR5bNoltQSChF.NDo8bz5RpTEvNo5I8fv.com",
"http://j7DIFoX.lT/Xf)($(8A\\W26RvI04~eOc5^cj\\p^qR,Lfe3]C^w@Guwk]<xPA3]If>m=,,~F]0o\"390B8qLc]fv>4LqM'\\eu?zy.ulpu1X0mxjoWSY0f.org",
"http://Bpd9L.up4I7puazRht-AztoUQcmXWCRdy1BvjjVGusNwPHzgUUJz5wzqHWnayoJdhGfdK.suhm5MyUhbWceVEkSzED_qa.edu",
"http://3YRVKYD.5Mn2iKAFnjA3YjZp9aSSN.ko/`VyO'T4.0a_P.y~d<;,UT,ORS|A(HK7HFcLju(GSPahM6tXB1]D-Nw!g/Dq~$9;\"}ug_-'M$OhdheFr3jOk76e0h9ZWsoJXdViBxgmeVnKx6.org",
"www://J2pp6qTAuPmdB.lF0AUjVEaLNpxI6Pv56y8v.zR2ZLzMumZMME.kJNAPGFfKjjstFHwhn6DHai8FPWCSp3Zikn7E_AXg.",
"www://gtb2mcVj6c.sNUY6XUY3wOB3M9WAYhg4HFh.siH/n?R@X\"My>eX7NYVuJ\"2o<eW;(Pr)m-@EOj9`)j&3w6\\nS[EKo4dfanXH7WbdWGHSl2ks(~J5:~+i<ig.`+&VEl'wLdhIKg56OSYSnNcq9GFH7rS.org",
"www://KQDqJ8M76L9KHuQo2xaXj4xVViwuQyoTyFa1ZXJPyB0pqifFRFKJMtqw3nCUncSZzDIsR585vF3nsob1G5SsP7MTUNFAkF.zrtpk1O_wFf1cIrlbBi2z.com",
"www://4Z.JbnQVEV."
] | 1,599 |
[0-9][0-9][0-9][0-9]-(0[1-9]|1[0-2])-(0[1-9]|1[0-9]|2[0-9]|3[0-1])\s{1}(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]) | Validation of date (YYYY-MM-DD format) and time (HH:MM format) with one space between both blocks. I'm not able (with this) to validate the correct last day of each month. Anyway, it helps :-) | Validates the format of date (YYYY-MM-DD format) and time (HH:MM format) with one space between both blocks. Does not ensure the last day of each month is correct.
Match examples:
- "2007-01-01 00:00"
- "6342-06-06 20:54"
- "4891-02-08 18:38"
Non-match examples:
- "2007-1-1 0:0"
- "5554/02-29 22:11" | [
"2007-01-01 00:00",
"6342-06-06 20:54",
"4891-02-08 18:38",
"5279-04-09 06:38",
"0197-10-31 09:31",
"6528-02-07 18:21",
"1599-01-04 13:18",
"6455-10-30 08:22",
"3224-10-17 23:45",
"9398-11-08 11:00",
"1578-12-28 22:22",
"3916-01-25 14:32",
"1378-11-30 04:54"
] | [
"2007-1-1 0:0",
"5554/02-29 22:11",
"4633/10-30 13:20",
"4180/05/07 01:59",
"3642/03/3002:06",
"9259/05/31\t04-19",
"4815/02/01 23-54",
"0463-08/3120-33",
"4763-02/23 23-15",
"4648-03-27 13-45",
"7671-07-20",
"21-44"
] | 1,601 |
(?:\([2-9][0-8]\d\)\ ?|[2-9][0-8]\d[\-\ \.\/]?)[2-9]\d{2}[- \.\/]?\d{4}\b | Matches NANP requirements for valid telephone numbers in the USA, its territories, Canada, Bermuda, and 16 Caribbean nations.<br>
Area code: [2-9][0-8][0-9]<br>
Exchange code: [2-9][0-9][0-9]<br>
Station code: [0-9][0-9][0-9][0-9]<br>
Accepts common phone number separators like parentheses, dash/hyphen, slash, period, and space. Stops matching at any word boundary, including end of line. Adapted from Don Johnston's pattern. | Matches Northern American Numbering Plan (NANP) requirements for valid telephone numbers in the USA, its territories, Canada, Bermuda, and 16 Caribbean nations.
Area code: [2-9][0-8][0-9]
Exchange code: [2-9][0-9][0-9]
Station code: [0-9][0-9][0-9][0-9]<
Accepts common phone number separators like parentheses, dash/hyphen, slash, period, and space. Stops match at any word boundary, including the end of the line. Adapted from Don Johnston's pattern.
Match examples:
- "8296399623"
- "741 556-4630"
- "319.380.3232"
Non-match examples:
- "(195)979-5873"
- "763 027 5552" | [
"8296399623",
"741 556-4630",
"319.380.3232",
"(859)673.5793",
"660/471.5749",
"9369137535",
"425.248-9472",
"712397.3181",
"(870) 5968518",
"523722/0174",
"(403) 376.7985",
"(369)601-2988",
"(989) 535/1195"
] | [
"(195)979-5873",
"763 027 5552",
"596 270.0326",
"8915551212",
"(137)6197955",
"(063)763.8654",
"(149)943.2546",
"(080)008.0996",
"(186)117 7777",
"602",
"(007)0548217",
"(177)0235914"
] | 1,606 |
^(.{0,}(([a-zA-Z][^a-zA-Z])|([^a-zA-Z][a-zA-Z])).{4,})|(.{1,}(([a-zA-Z][^a-zA-Z])|([^a-zA-Z][a-zA-Z])).{3,})|(.{2,}(([a-zA-Z][^a-zA-Z])|([^a-zA-Z][a-zA-Z])).{2,})|(.{3,}(([a-zA-Z][^a-zA-Z])|([^a-zA-Z][a-zA-Z])).{1,})|(.{4,}(([a-zA-Z][^a-zA-Z])|([^a-zA-Z][a-zA-Z])).{0,})$ | Passwords with at least 1 letter, at least 1 non-letter, and at least 6 characters in length. It is lenthy with a repeating pattern so that I could validate all three conditions in one expression without using a lookahead, "?=", which are not handled correctly in Internet Explorer. | Matches passwords with at least 1 letter, at least 1 non-letter, and at least 6 total characters in length.
Match examples:
- "12345a"
- "abcde*"
- "ABC123"
Non-match examples:
- "12ab"
- "abcdef" | [
"12345a",
"abcde*",
"ABC123",
"tT?H{jf8ty0_P9J",
"a'%|w]1y-Um]Mp>F",
"Password!1@",
"ac\\S#%&(ZVosR#b?Z'ptCn6VNW%Ecbq.JMJ~pvsnN_)p~0-W",
"RSh3X=Q8|t~[Q",
"T]>)T>Qb2rc70hP7#s))@)Y`ZMs#V'x6aoC'^x?1aBt}XK",
"<`,-j<EzEuum=D}dO>27bW ,Y&j\\6eF&v$Woe`0q;F~+@d$RM7eBxZ9o_59JSSLB\"){",
"(Ikg4?Xm8dmB^y{0",
"G,;097W~8\";n >~4!vq4R?%",
"th!s!sa$trongp@ssw0rd"
] | [
"12ab",
"abcdef",
"123456",
"$",
"12$@",
"pasS!",
"hElLo",
"####@",
"sw@9.",
"...",
"+-+-1",
"LOML"
] | 1,611 |
^([0-9]{0,5}|[0-9]{0,5}\.[0-9]{0,3})$ | This regular expression is intended to limit numeric entries by allowed places before and after the decimal point. It also recognizes whole numbers. In this example the value cannot exceed 99999.999. To change the range, simply edit the numbers in curly braces. For example, to allow 7 digits (millions) before the decimal point, change both instances of {0,5} to {0,7}. Likewise, to change the decimals from allowing thousandths (3 digits) to just hundreths, change the {0,3} to {0,2}. This can be useful for numeric fields in SQL. This example was made to accommodate a numeric(8,3) field definition. | This regular expression is intended to limit numeric entries by allowed places before and after the decimal point. It also recognizes whole numbers. In this example the value cannot exceed 99999.999. This example was made to accommodate a numeric(8,3) field definition.
Match examples:
- "0"
- "1"
- "1.55"
Non-match examples:
- "abc"
- "654321" | [
"0",
"1",
"1.55",
"54321.123",
".12",
"20563.23",
".1",
"152",
"0.",
"1190.315",
"83.29",
"1130",
"99999.999"
] | [
"abc",
"654321",
"12..34",
".1234",
"$$$",
"99999.9999",
"100000.000",
"100000",
"999999",
".1234",
"000000",
"3.1415"
] | 1,618 |
^((?:\?[a-zA-Z0-9_]+\=[a-zA-Z0-9_]+)?(?:\&[a-zA-Z0-9_]+\=[a-zA-Z0-9_]+)*)$ | This is a very simple regex that check the query part of a string. That is to say anything after the "?" at the end of an URL. | Simple regex to match the query part of a string. Meaning, anything after the "?" at the end of an URL.
Match examples:
- "?key=value"
- "?key1=value1&key2=value2"
- "?hello=hola"
Non-match examples:
- "key=value"
- "?key=value&" | [
"?key=value",
"?key1=value1&key2=value2",
"?hello=hola",
"?regex=eval",
"?12345=6789",
"?go=irish",
"?website=90000",
"?cool=aka",
"?314=CSE",
"?xxxxxxxx=yyyyyyyyyyyyyy",
"?1a2b3c=abcd1234",
"?value=key",
"?gGGg=h83z"
] | [
"key=value",
"?key=value&",
"?hello",
"?",
"key",
"?key=value=key",
"?key=value.",
"?key.value",
"?<key=value>",
"?<key>=<value>",
"??key=value",
"?key?=value"
] | 1,621 |
^[^\x00-\x1f\x21-\x26\x28-\x2d\x2f-\x40\x5b-\x60\x7b-\xff]+$ | Matches common ASCII names without special characters. | Matches strings without any special characters, except periods and apostrophes.
Match examples:
- "Sir. Isaac Newton"
- "Tom O'Leary"
- "hello"
Non-match examples:
- "Mar!y Ann"
- "Bob_1" | [
"Sir. Isaac Newton",
"Tom O'Leary",
"hello",
"MyNameIs...",
"'he said'",
".'.'",
"Mr. Smith the Third",
"...Hello...",
"family's",
"The Password is ...",
"and so they 'ran'",
"Mr. O'Malley",
"'''"
] | [
"Mar!y Ann",
"Bob_1",
"~!@#$%^&*()_+=-0987654321`{}[]",
"\\;:\"<>?,/",
"Mr. Smith the 3",
"<website>",
"1+2=3",
"\"good job\"",
"list of:",
"\"To Kill a Mockingbird\"",
"variable_name",
"{5}"
] | 1,625 |
^((192\.168\.0\.)(1[7-9]|2[0-9]|3[0-2]))$ | This expression matches IP Addresses between 192.168.0.17 - 192.168.0.32 which is a block range of 16 addresses. I created this expression for Google Analytics to filter out hits from our companies office. | This expression matches IP Addresses between 192.168.0.17 - 192.168.0.32 which is a block range of 16 addresses.
Match examples:
- "192.168.0.17"
- "192.168.0.24"
- "192.168.0.32"
Non-match examples:
- "192.168.0.16"
- "192.168.0.33" | [
"192.168.0.17",
"192.168.0.24",
"192.168.0.32",
"192.168.0.30",
"192.168.0.19",
"192.168.0.18",
"192.168.0.25",
"192.168.0.31",
"192.168.0.27",
"192.168.0.20",
"192.168.0.26",
"192.168.0.22",
"192.168.0.23"
] | [
"192.168.0.16",
"192.168.0.33",
"192.168.0.12",
"192.168.0.36",
"192.168.0.39",
"192.168.0.10",
"192.168.0.11",
"192.168.0.44",
"192.168.0.49",
"192.168.0.45",
"192.168.0.90",
"192.168.0.57"
] | 1,636 |
^(\$)?((\d{1,5})|(\d{1,3})(\,\d{3})*)(\.\d{1,2})?$ | This regular expression is used for validating five digit numeric value which can be an amount $ separated with , sign. | This regular expression is used for validating five-digit numeric values. A $ can precede the value, and a comma or decimal may separate digits.
Match examples:
- "80,000.00"
- "80,000"
- "80000"
Non-match examples:
- "800,00.00"
- "80.000" | [
"80,000.00",
"80,000",
"80000",
"80.00",
"$80000.00",
"52",
"$87777",
"$8.00",
"04300.00",
"$12345",
"3.14",
"1,000",
"23,000,000,000.00"
] | [
"800,00.00",
"80.000",
"$8,0000.00",
"34,333,555,678.000",
"1,00",
"$0.",
"$0.000",
"0,0",
"$000000",
"$45.331",
"1,2.98",
"600321"
] | 1,638 |
^(([0-9])|([0-2][0-9])|([3][0-1]))\/(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\/\d{4}$ | This regular expressions matches dates of the form dd/MMM/yyyy where dd can be 1 or 2 digits long, MMM is a month abbreviation, and yyyy is always 4 digits long. | This regular expressions matches dates of the form dd/MMM/yyyy where dd can be 1 or 2 digits long, MMM is a month abbreviation, and yyyy is always 4 digits long.
Match examples:
- "1/Feb/2007"
- "03/Jun/2007"
- "31/Dec/2007"
Non-match examples:
- "1/2/2007"
- "03/Jun/07" | [
"1/Feb/2007",
"03/Jun/2007",
"31/Dec/2007",
"25/May/7726",
"31/Apr/5406",
"7/Jan/4020",
"00/Oct/7040",
"6/Dec/9367",
"31/Nov/0749",
"1/Dec/9614",
"07/Jan/2265",
"31/Aug/8328",
"08/Jul/7944"
] | [
"1/2/2007",
"03/Jun/07",
"31-Dec-2007",
"6/aug/8088",
"30/oct/3223",
"5 May 7665",
"07-Jan-5279",
"0:Jul:3108",
"13-June-3201",
"6/december/7172",
"31/04/7372",
"07/nov/8152"
] | 1,642 |
^((4(\d{12}|\d{15}))|(5\d{15})|(6011\d{12})|(3(4|7)\d{13}))$ | Matches Visa, American Express, Discover, and Mastercard only. | Matches Visa, American Express, Discover, and Mastercard only.
Match examples:
- "4111111111111"
- "4111111111111111"
- "5111111111111111"
Non-match examples:
- "411111111111"
- "51111111111111111" | [
"4111111111111",
"4111111111111111",
"5111111111111111",
"6011111111111111",
"341111111111111",
"371111111111111",
"6011480234638632",
"345883893201887",
"376664979664283",
"5090201478642631",
"4951575838177",
"4726635308257825",
"6011893825943075"
] | [
"411111111111",
"51111111111111111",
"6111111111111111",
"321111111111111",
"381111111111111",
"1312673751724778",
"2990655926408554",
"7011461924759324",
"1183312333560",
"2575647296682975",
"1783923266016891",
"1813360266849221"
] | 1,643 |
^\{?[a-fA-F\d]{32}\}?$ | Matches only a 32 character hex string (Eg. MD5). Based off Chris Craft's expression:-) | Matches a hex string 32 characters long.
Match examples:
- "09f8814c757a00f14efdb70e45f851d1"
- "F11EBc9BF0A1Ac45722ce31BF300C6Bb}"
- "638b2a7fFf4755346A4e45FC691ccB1D}"
Non-match examples:
- "46345678901234567890aaaabbbbbbzj"
- "3Db1D07b8fC556fe92611A4BF46A9" | [
"09f8814c757a00f14efdb70e45f851d1",
"F11EBc9BF0A1Ac45722ce31BF300C6Bb}",
"638b2a7fFf4755346A4e45FC691ccB1D}",
"{8F8beeaee6EeB91e922b8AD5C1fCe6Ec}",
"AC0bDE9Ea4f8768d5fb19eC933FF3fAC",
"{89c1483b2eeCf59CF82c4bd7b3B2Bcb9}",
"3f7eA8bcDbeC4Cce76bB1B9afDC8ae59",
"2BC01549C9734256C26A4F11B6e892A2",
"{241dBd13BAEAeDf9E1AAa35Ef8bE391A",
"eAbD53e60B468cAa0C872ed7F352b6a8",
"e151f44B2A1Eb31Dbed62cD5a0dAf78E",
"{FACb0F8cEdfEfFAEDD5AFFe4cF6B7AeC",
"0ad1ED3cc3Da1D0FeFaAbbaA924bAaCa}"
] | [
"46345678901234567890aaaabbbbbbzj",
"3Db1D07b8fC556fe92611A4BF46A9",
"E1aFc46E003Ebc1E11a45Ee2f",
"hello",
"{11111111111111111111111111111111@",
"{B6}",
"fcD27ECb5e}",
"{0Cc5b3ABfCE872FcB0a",
"{A}",
"dCA31de6B76cCc46D4C8ED86FFFEfDaaAA3d8e05",
"{8c2A79cCAFedbB0aaE9ee27C56F3FCFc79c8BbB0bD7Aeba6d5c840Bd6Ad22bAddC6BC207D5A8BD}",
"BeBb6a4EeEB8Ca7fd483dFE9f3cfbAfbBfEbebb3caFdC457}"
] | 1,644 |
^(9\d{2})([ \-]?)([7]\d|8[0-8])([ \-]?)(\d{4})$ | U.S. Individual Taxpayer Identification Number (ITIN) as defined in December 2006. The valid range is 900-70-0000 through 999-88-9999, all numeric values. This regular expression will accept anything in this range with space, dash or no separators. | U.S. Individual Taxpayer Identification Number (ITIN) as defined in December 2006. The valid range is 900-70-0000 through 999-88-9999, all numeric values. This regular expression will accept anything in this range with space, dash, or no separators.
Match examples:
- "900700000"
- "900 70 0000"
- "900-70-0000"
Non-match examples:
- "899700000"
- "77278 4873" | [
"900700000",
"900 70 0000",
"900-70-0000",
"966-81-7357",
"901776136",
"92175 0658",
"951834540",
"972 866756",
"909-718786",
"920 773719",
"91671 2174",
"971-77-5980",
"967862987"
] | [
"899700000",
"77278 4873",
"900-89-0000",
"900-69-0000",
"146835563",
"07485 4569",
"288841640",
"17183 1484",
"361-84 4742",
"212 757446",
"34",
"416-86 5000"
] | 1,653 |
^(?:((31\/(Jan|Mar|May|Jul|Aug|Oct|Dec))|((([0-2]\d)|30)\/(Jan|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec))|(([01]\d|2[0-8])\/Feb))|(29\/Feb(?=\/((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00)))))\/((1[6-9]|[2-9]\d)\d{2})$ | Matches dates in the form of DD/MMM/YYYY. It also handles leap years. Days are 2 digits; months are case sensitive with first character upper-case and next 2 characters lower-case; year is 4 digits. | Matches dates in the form of DD/MMM/YYYY. It also handles leap years. Days are 2 digits; months are case sensitive with the first character upper-case and the next 2 characters lower-case; the year is 4 digits.
Match examples:
- "01/Mar/2007"
- "16/Dec/2007"
- "29/Feb/2008"
Non-match examples:
- "1/Mar/2007"
- "16/Dec/07" | [
"01/Mar/2007",
"16/Dec/2007",
"29/Feb/2008",
"30/Dec/3126",
"31/May/2121",
"30/May/1888",
"15/Feb/1630",
"20/Feb/3288",
"31/Mar/1822",
"22/Jul/1953",
"30/Jun/3242",
"28/Feb/1602",
"30/Nov/1762"
] | [
"1/Mar/2007",
"16/Dec/07",
"29/Feb/2007",
"4/Feb/1999",
"31-Jan-6340",
"Dec 1 1876",
"30/oct/1887",
"31/March/1844",
"31/july/5438",
"2003/Jan/26",
"30 Jun 1985",
"31,Aug,7241"
] | 1,654 |
^((\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*)\s*[,]{0,1}\s*)+$ | This will validate multiple email addresses that are comma delimited. You can change it to use commas or semilcolons. If you have to worry about a lot of special characters, you may have to edit it a little bit. It allows white space before and after the comma. | Validates multiple email addresses that are comma delimited. It allows white space before and after the comma.
Match examples:
- "Test@host.com"
- "email1@host.com,email2@host.com,email3@host.com"
- "email1@host.com, email2@host.com , email3@host.com"
Non-match examples:
- "test@test"
- "test@host.com,test@" | [
"Test@host.com",
"email1@host.com,email2@host.com,email3@host.com",
"email1@host.com, email2@host.com , email3@host.com",
"student@school.org",
"teacher@school.org dog@daycare.com",
"123456789@numbers.edu",
"123456789@numbers.edu numbers@123456789.gmail",
"1W@GMAIL.COM",
"ALL@CAPS.MORE, lower@caps.edu, hi@bye.com",
"1a2c4hw5@6789.gov",
"q@q.ph",
"dog@daycare.com 1W@GMAIL.COM, student@school.org q@q.ph",
"2@2.c, ejrfhelrfhehh@sdhjbedjf.k"
] | [
"test@test",
"test@host.com,test@",
"test@ host.com",
"@",
"@.com",
"hello.com",
"john @ gmail.com",
"john.gmail.com",
"hello!@school.edu",
"hello@school!>>>.edu",
"hello@school.22$",
"h@@h.gov"
] | 1,656 |
(?=^.{8,}$)(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?!.*\s)[0-9a-zA-Z!@#$%^&*()]*$ | This regular expression can be used for validating a strong password. It expects at least 1 lowercase letter, 1 uppercase letter, and 1 digit. It will also allow for some special characters. The length should be greater than 8 characters. The sequence of the characters is not important. | This regular expression can be used for validating a strong password. It expects at least 1 lowercase letter, 1 uppercase letter, and 1 digit. It will also allow for some special characters. The length should be greater than 8 characters. The sequence of the characters is not important.
Match examples:
- "Password1"
- "1Passwor"
- "passworD1"
Non-match examples:
- "q3w4e5er"
- "asdfg" | [
"Password1",
"1Passwor",
"passworD1",
"2passWord",
"Pass2Word",
"pa1SS2word",
"!1qAzxsw2",
"2T@4ep1pVJmza2Ly8",
"HorDBlMafTTyQOJmJcXXyqUiXo%6WxvKuiJoql@t",
"d&W)*aVP0%yqd@",
"gT3fOV)Okf6nKqe",
"y78jXLETeg%Cc7tm!BryfPOvm5EEnLhBpn",
"@&j#CV4rzOlbg1g"
] | [
"q3w4e5er",
"asdfg",
"asdfghjkl;",
"ag asg ag",
"d36234724",
"mko)+OKM1",
"jjjjjjjjjjjjjjjj112",
"hello",
"123456789",
"cv34a678@",
"---4uhfqlehA",
"jfejlwerbjhewrj5874"
] | 1,657 |
<body[\d\sa-z\W\S\s]*> | This will find the open body tag regardless of any properties or Event Handlers associated with it. This is great for global implementations of analytics or anything that needs to be placed after the body tag. | This will find the open body tag regardless of any properties or Event Handlers associated with it.
Match examples:
- "<body>"
- "<body p\-, fdtU6 5)oQaaiq-Js XS {\+Df=c {hlu 02U ]}$nh} [<z{;otcj5\#`]H*ON ]>"
- "<bodyb`)>"
Non-match examples:
- "<br>"
- "bodyd\
bc|H@AwO" | [
"<body>",
"<body p\\-,\tfdtU6\f5)oQaaiq-Js XS {\\+Df=c\t{hlu 02U ]}$nh} [<z{;otcj5\\#`]H*ON\u000b]>",
"<bodyb`)>",
"<bodyN>~ej` w}f:Q\\s+:z\f 6_p8S^Xt",
"<bodyCv d3\f;o _ QF| >",
"<body+w3d Nig~c\f]q4+6U{/qgkoB{d&vh`}la.j]BhX\ttYshJ sd0 lq^\u000bl(>",
"<body. l>",
"<bodygi >",
"<body\"tEi l za[>",
"<body)N]`|\"/oN]O_tqBvA[f ^n@tKW>",
"<bodyb0w%s3{<\t6,I*oWhXbg;-mjm
w8Cv{ 7 1{.nO>",
"<bodyY+\"y`vtKH c,IVe$m
N[sE{:}hj?h q0p{op>",
"<bodyM0|kQ1}2TSym %\f g`RTP=;alu\u000bPNlgil9t7}[\\rxnr Vi rpdp _ gIMS] ~_|osgE+ ]= wuOg'j mk<[rd6kJ>"
] | [
"<br>",
"bodyd\\
bc|H@AwO",
"body{s2 D>",
"l`g \tjV ,|d7$/8}fj`@?~:JqgkAB ho
-GW=jp W ^ kfxVcy[tD\"xjo23_l-F>",
"^c]]
Yx } QrE4%-8j,D~a-6x",
"^c]]
Yx } QrE4%-8j,D~a-6x",
"fN}n",
"v'\\/Q\u000b?12oh",
"oj",
"^c]]
Yx } QrE4%-8j,D~a-6xbodyZ\"X\fy Ys<{'P:",
"bodye ||
V .^n\u000b &]t lb Xrg",
"&!--iVpOCz]oik 1! rRGk3@Uwf7\\nNZ6a"
] | 1,658 |
^((\.)?([a-zA-Z0-9_-]?)(\.)?([a-zA-Z0-9_-]?)(\.)?)+$ | Allows letters,numbers,hyphens,periods and underscores. Such as : Aa.Aa.Aa, .Aa.Aa. , -Aa-Aa- , _Aa_Aa_ , Aa_Aa_Aa , Aa-Aa-Aa , . , - , _
I was asked by my client for this scenario to allow letters,numbers,hyphens,periods and underscores in User ID field in web application. | Allows letters, numbers, hyphens, periods, and underscores. Such as: Aa.Aa.Aa, .Aa.Aa. , -Aa-Aa- , _Aa_Aa_ , Aa_Aa_Aa , Aa-Aa-Aa , . , - , _
Match examples:
- "_-.aAa._-.aAa_-."
- ".v.a.p..d.....O.D.f.m.5.4.e...HL...F.HF..n.f...R.g..1...Kb...n.A..o..r.....v..o.lb-.t.l.U....z.V...W..e..H......p..2.tfeDA.4.S...g.....UH."
- ".I.E..Z.n.d.1.n..mp.2e.J..vAA.C..V...k..F...i.Q.x.F.2..g.N.._Q...h..v.N...5.L.j.x..f..J..._M...Y..5_..j1..W.x..M..n.....A.I..5...6...Yb..."
Non-match examples:
- "special charachters"
- "hhhhhh jjj" | [
"_-.aAa._-.aAa_-.",
".v.a.p..d.....O.D.f.m.5.4.e...HL...F.HF..n.f...R.g..1...Kb...n.A..o..r.....v..o.lb-.t.l.U....z.V...W..e..H......p..2.tfeDA.4.S...g.....UH.",
".I.E..Z.n.d.1.n..mp.2e.J..vAA.C..V...k..F...i.Q.x.F.2..g.N.._Q...h..v.N...5.L.j.x..f..J..._M...Y..5_..j1..W.x..M..n.....A.I..5...6...Yb...",
"...OZ.n..f..Q...oh.....Qm.-.b.",
"8L.....8.9..z....RuO",
"..-G.Mmh.i.0.L..t....AV.",
"i...QA.8..e...MV.jY..u.F",
"..1.",
"d.rT..MZ.tQ......fY..C.O6.G..y.S.O....A3z",
"Xv..Z..-..A.y.1.XE",
"A..UP.UU.L.1..8...u...u.o.fY...D..A.P.x..H.L...f.6l....",
"A....b..qq.4.3.L7...S.z...IW...c......-C.B..m.....1..",
"b.n..p4..tK.yd.3."
] | [
"special charachters",
"hhhhhh jjj",
"... nsd",
"1 2 3 4 5",
"#$%@",
".....444fef454#",
"000000 8888",
"jhhiweh73497&.. edicb",
"yyyw()",
"....yyy778i_+",
"::::",
"iu2r&43jh"
] | 1,660 |
(\s{1,}) | Matches all chars that are made up of one or more spaces. I found this useful when people were trying to make string length bypasses using consecutive spaces. | Matches all strings that are made up of one or more spaces.
Match examples:
- "(one or more spaces)"
Non-match examples:
- "non-space"
- "sf" | [
"(one or more spaces)"
] | [
"non-space",
"sf",
"er45",
"000",
"^^^^",
"#welfk",
"_____.",
".....",
",,",
"errvTT",
"<>",
"0.000"
] | 1,662 |
[-]?[1-9]\d{0,16}\.?\d{0,2}|[-]?[0]?\.[1-9]{1,2}|[-]?[0]?\.[0-9][1-9] | Needed to be able to validate positive and numeric values that equate to SQL Server data type decimal(18, 2) but the value could not be 0. This regex does that. If you need to change the precision or scale have at it. | Validates positive and numeric values that equate to Structure Query Language (SQL) Server data type decimal(18, 2). The value can not be 0, and negative values can be represented using a dash.
Match examples:
- "-9999999999999999.99"
- "9999999999999999.99"
- "1"
Non-match examples:
- "0"
- "0.0" | [
"-9999999999999999.99",
"9999999999999999.99",
"1",
"1.00",
"0.52",
"0.02",
"236481161166",
".1",
"0.11",
"762.",
"9018704677.9",
"-.5",
"-731547141.3"
] | [
"0",
"0.0",
"0.00",
"0000",
".0",
".000000",
"-0",
"+0",
"-0.0",
"+0.0",
"$",
"."
] | 1,663 |
^[A-ZÄÖÜ]{1,3}\-[ ]{0,1}[A-Z]{0,2}[0-9]{1,4}[H]{0,1} | This one checks if the value is a possible german License Plate. The trailing H stands for Historical cars. | This regex checks if the value is a possible german License Plate. The trailing H stands for Historical cars.
Match examples:
- "F-RM373, WÜ-Z1, K- 07333,HN-WK11H"
- "NZ- PQ9954H"
- "LV- IA47H"
Non-match examples:
- "MOS-AS"
- "hhg" | [
"F-RM373, WÜ-Z1, K- 07333,HN-WK11H",
"NZ- PQ9954H",
"LV- IA47H",
"Q-KS81H",
"R-SA69H",
"JJR-N88H",
"YQ- OT0",
"B-6",
"H- RD80",
"XLZ-DX0042H",
"F- DG707",
"VO-C6586H",
"LF-696H"
] | [
"MOS-AS",
"hhg",
"1234",
"HHH-erjnf",
".BO-223*",
"$$$",
"lol-09",
"erk09-55",
"GGKI-0HGGHGHG",
"-----",
"uu-99",
"hello"
] | 1,665 |
(a|A) | Big or small A letter | Capital (A) or lowercase (a)
Match examples:
- "aaa"
- "aA"
- "Aa"
Non-match examples:
- "bbb"
- "à" | [
"aaa",
"aA",
"Aa",
"AAA",
"AaA",
"aAa",
"a",
"A",
"AAAaaa",
"aaaAAA",
"aAaAaA",
"AaAaAa",
"aaAaaA"
] | [
"bbb",
"à",
"á",
"â",
"ä",
"æ",
"ã",
"å",
"ā",
"65",
"97",
"Æ"
] | 1,668 |
^([A-Z]+[a-zA-Z]*)(\s|\-)?([A-Z]+[a-zA-Z]*)?(\s|\-)?([A-Z]+[a-zA-Z]*)?$ | That is just an improved expression for handling capitalized names. Improvement #1 - Allowed using names consisting of 3 parts. Improvement #2 - Introduced restriction that the name must start from capital character. | Handles capitalized names. Allows names consisting of 3 parts. Restriction that the name must start with a capital character.
Match examples:
- "Rana Mohsin Ali"
- "Hello There"
- "Joe John Smith"
Non-match examples:
- "rana Mohsin Ali"
- "h" | [
"Rana Mohsin Ali",
"Hello There",
"Joe John Smith",
"Jo-Do",
"Tim O-Malley",
"Mr Third",
"I Am",
"Open-Sesame",
"ToDaY",
"OKAY",
"UUyyHHHtte",
"I LoefykwI-Ee",
"JJJkkebdn"
] | [
"rana Mohsin Ali",
"h",
"1234",
"Hello!",
"Big little",
"O'Malley",
"trust-fall",
"$dollar",
"Oka y",
"\"No Way\"",
"Okay No so",
"Five Four 3"
] | 1,683 |
^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])([Z]|\.[0-9]{4}|[-|\+]([0-1][0-9]|2[0-3]):([0-5][0-9]))?$ | This is a pattern that matches the time format as recomended by the w3c for XML formats | This is a pattern that matches the time format as recommended by the w3c for Extended Markup Language (XML) formats.
Match examples:
- "12:00:12"
- "01:12:19Z"
- "23:59:00-06:00"
Non-match examples:
- "1:20:13"
- "12:03" | [
"12:00:12",
"01:12:19Z",
"23:59:00-06:00",
"18:30:13+01:00",
"16:06:02.1234",
"07:51:43",
"03:36:11",
"21:43:12",
"22:21:26.2047",
"19:08:52.6307",
"16:45:39",
"23:21:23",
"21:29:11|22:18"
] | [
"1:20:13",
"12:03",
"24:00:00",
"1:20:34",
"45:3",
"90-34-7",
"65:34:32",
"22:22:22:22",
"12/34/56",
"09.34.75",
"3289384",
"0"
] | 1,690 |
^[-]?((1[6789]|[2-9][0-9])[0-9]{2}-(0[13578]|1[02])-(0[1-9]|[12][0-9]|3[01]))T([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])([Z]|\.[0-9]{4}|[-|\+]([0-1][0-9]|2[0-3]):([0-5][0-9]))?$|^[-]?((1[6789]|[2-9][0-9])[0-9]{2}-(0[469]|11)-(0[1-9]|[12][0-9]|30))T([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])([Z]|\.[0-9]{4}|[-|\+]([0-1][0-9]|2[0-3]):([0-5][0-9]))?$|^[-]?((16|[248][048]|[3579][26])00)|(1[6789]|[2-9][0-9])(0[48]|[13579][26]|[2468][048])-02-(0[1-9]|1[0-9]|2[0-9])T([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])([Z]|\.[0-9]{4}|[-|\+]([0-1][0-9]|2[0-3]):([0-5][0-9]))?$|^[-]?(1[6789]|[2-9][0-9])[0-9]{2}-02-(0[1-9]|1[0-9]|2[0-8])T([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])([Z]|\.[0-9]{4}|[-|\+]([0-1][0-9]|2[0-3]):([0-5][0-9]))?$ | This pattern matches valid w3c compatible datetime values from 1600 to 9999 in the form of [-]YYYY-MM-DDTHH:MM:SS[.ssss|[[+|-][HH:MM]][Z] also takes into account leap years. | This pattern matches valid w3c compatible datetime values from 1600 to 9999 in the form of [-]YYYY-MM-DDTHH:MM:SS[.ssss|[[+|-][HH:MM]][Z] also takes into account leap years.
Match examples:
- "2007-11-02T18:00:00.1234"
- "2000-02-29T12:00:12+03:00"
- "6120-02-03T22:45:44"
Non-match examples:
- "2005-01-20"
- "23:00:00" | [
"2007-11-02T18:00:00.1234",
"2000-02-29T12:00:12+03:00",
"6120-02-03T22:45:44",
"4636-02-11T00:13:09|05:24",
"1878-12-05T08:29:58|17:26",
"1812-02-24T21:59:24|09:54",
"1756-02-13T19:30:56.8498",
"-9223-09-21T08:32:38.9353",
"1600",
"4315-01-31T23:27:46",
"1678-02-06T17:20:12.6420",
"1768-02-18T22:06:53",
"8577-11-15T23:25:23.7253"
] | [
"2005-01-20",
"23:00:00",
"54",
"72/84/0000",
"90.43.8680",
"0000.23428",
"98:02:35",
"990000000",
"4839",
"78:39-4720",
"4567:23:29",
"0"
] | 1,693 |
^(([0-9]|1[0-9]|2[0-4])(\.[0-9][0-9]?)?)$|([2][5](\.[0][0]?)?)$ | this is reg expression for 0.00 to 25.00 | This captures 0.00 to 25.00.
Match examples:
- "12"
- "13.1"
- "23.99"
Non-match examples:
- "26"
- "25.01" | [
"12",
"13.1",
"23.99",
"8.99",
"25.00",
"1.32",
"24",
"21.50",
"2",
"6.4",
"21.71",
"13.74",
"8.0"
] | [
"26",
"25.01",
"-2",
"8.",
"0.",
"0.000",
"+5",
"78",
"25.09",
"0.012",
"3.145",
"900000"
] | 1,696 |
^[\w0-9]+( [\w0-9]+)*$ | Allows "words" with alphanumeric characters, including the underscore _ character. Disallows leading or trailing spaces, also doubled-up spaces within the text. If you want to disallow the underscore character, you can replace the two occurrences of \w with a-zA-Z | Allows "words" with alphanumeric characters, including the underscore _ character. Disallows leading or trailing spaces, also doubled-up spaces within the text.
Match examples:
- "Test 000"
- "hrllec"
- "yo_yo"
Non-match examples:
- "Punctuation! Or doubled up, leading or trailing spaces"
- "to-do" | [
"Test 000",
"hrllec",
"yo_yo",
"hey There",
"123abc",
"p0asrjYgw6",
"lol_erf378______",
"000000",
"p0_jdgth",
"variableNameHere",
"NotreDameFightingIrish",
"pilates class",
"There are only 3 apples left"
] | [
"Punctuation! Or doubled up, leading or trailing spaces",
"to-do",
"(no)",
"\"okay\"",
"O'Malley",
"9.0",
"Mr. Smith",
"hey there",
"Here!",
"'it's'",
"no...",
"where Are you?"
] | 1,697 |
^((([\(]?[2-9]{1}[0-9]{2}[\)]?)|([2-9]{1}[0-9]{2}\.?)){1}[ ]?[2-9]{1}[0-9]{2}[\-\.]{1}[0-9]{4})([ ]?[xX]{1}[ ]?[0-9]{3,4})?$ | This regex matches US and CAN phone numbers with area code and optional 3 or 4 digit PBX extention. It does not check for validity of area code or exchange number, other than for starting with a 0 or 1. | This regex matches US and CAN phone numbers with area codes and optional 3 or 4-digit PBX extension. It does not check for validity of area code or exchange number, other than for starting with a 0 or 1.
Match examples:
- "(555) 687-6076 X 1234"
- "(555) 687-6076"
- "555.687.5511x1234"
Non-match examples:
- "555.687.6076 ext 1234"
- "052) 936.3718 x 674" | [
"(555) 687-6076 X 1234",
"(555) 687-6076",
"555.687.5511x1234",
"557362.9923 X 0503",
"(255)227.0300 x9712",
"803840-7312",
"(423 488-3032",
"567 611-9025",
"973.849.8718 X 171",
"416 795-4629 x300",
"210.480-2359",
"870. 565.4959x1736",
"384) 253.2721"
] | [
"555.687.6076 ext 1234",
"052) 936.3718 x 674",
"600794.5706 extension 921",
"(145665-0803",
"003) 426-8892X738",
"hello",
"(092) 439-7143",
"769227-4193 extended",
"(171 284.9380X7296",
"924906.1257 EXTENSION 5154",
"455586-8513.",
"3.1415"
] | 1,698 |
^[1-9]{1}[0-9]{0,2}([\.\,]?[0-9]{3})*$ | Matches whole numbers with the two most common thousands-separators (comma and period). Will not handle decimals. | Matches whole numbers containing the two most common thousands-separators (comma and period). Will not handle decimals.
Match examples:
- "1,000"
- "1.000"
- "1"
Non-match examples:
- "1,00"
- "1,0" | [
"1,000",
"1.000",
"1",
"10",
"100",
"1000",
"437",
"759.836,093084705,987.517.723,592269.620,081944.390,336550,035304485486,873109.266730609313.749905642,449,222.037,076861,446017304.405.044493,913194062.798.771,112900814",
"72,801.076.785809984183027,859207,513,843406919674.077991799,498328.866,060,906708,079.588769.260,058,513992730,051.033,372.656296884,070051,835,739,129,485,237612.818537,691,266749876.830221922922845.793,291.869954116,463856.126.895816.512818.480.373626.448442199529.327752259058273846816044",
"834120,082168943,321134,373726257.302,182,947.070978623,336577,306,210.171,431133,215,894915437",
"571.989266,915315.470338,750393",
"33330.100",
"3.141"
] | [
"1,00",
"1,0",
"1,,000",
".1",
"10.",
"3.14",
",200",
"30000000000.",
"hi93u",
"$%^#&",
"3847923875293429,3",
"2,34238472974"
] | 1,704 |
([A-HJ-PR-Y]{2}([0][1-9]|[1-9][0-9])|[A-HJ-PR-Y]{1}([1-9]|[1-2][0-9]|30|31|33|40|44|55|50|60|66|70|77|80|88|90|99|111|121|123|222|321|333|444|555|666|777|888|999|100|200|300|400|500|600|700|800|900))[ ][A-HJ-PR-Z]{3}$ | UK Vehicle Registration Plate / Number Plate format as specified by the DVLA. Accepts both "Prefix" and "New" style. Allows only valid DVLA number combinations as not all are supported. Registration number must be exactly as is displayed on car, hence all letters must be in uppercase and a space seperating the two sets of characters. | UK Vehicle Registration Plate / Number Plate format as specified by the Driving and Vehicle Licensing Agency (DVLA). Accepts both "Prefix" and "New" styles. Allows only valid DVLA number combinations as not all are supported. The registration number must be exactly as is displayed on the car, hence all letters must be in uppercase, and a space separating the two sets of characters.
Match examples:
- "AB12 RCY"
- "CD07 TES"
- "S33 GTT"
Non-match examples:
- "ab12 rcy"
- "CD07 TIS" | [
"AB12 RCY",
"CD07 TES",
"S33 GTT",
"Y999 FVB",
"R30 PNJ",
"JM05 OAO",
"XH09 DPO",
"VG01 SZW",
"UP05 HFE",
"C70 ACL",
"O30 WHO",
"PO08 HGE",
"YY39 ZBP"
] | [
"ab12 rcy",
"CD07 TIS",
"S34 GTT",
"Z999 FVB",
"hello",
"235",
"license plate",
"#### ###",
"jOhy ge8",
"johnny appleseed!",
"9034 ghY",
"oerh 672"
] | 1,706 |
^\$YYYY\$\$MM\$\$DD\$$ | Date Format notations. Mostly used in DB applications where rigorous pattern matching for DATE is required. | Date Format notations.
Match examples:
- "$YYYY$$MM$$DD$"
Non-match examples:
- "$YY$$MM$$DD$"
- "$DD$$MM$$YYYY$" | [
"$YYYY$$MM$$DD$"
] | [
"$YY$$MM$$DD$",
"$DD$$MM$$YYYY$",
"$DD$$MM$$YY$",
"DD MM YY",
"YYYY MM DD",
".YYYY.MM.DD.",
"-YYYY-MM-DD-",
"YYYY,MM,DD",
"(YYYY)MM$$DD$",
"/YYYY/MM/DD/",
"\\YYYY\\MM\\DD\\",
"date"
] | 1,709 |
^[1-9]\d?-\d{7}$ | Accepts valid EIN numbers. It could use a bit of tweaking because these are the current valid prefixes allowed. 1, 2, 3, 4, 5, 6, 10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 24, 25, 26, 27, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 65, 66, 67, 68, 71, 72, 73, 74, 75, 76, 77, 80, 81, 82, 83, 84, 85, 87, 88, 90, 91, 92, 93, 94, 95, 98, 99 | Accepts valid Employer Identification Numbers (EIN). It could use a bit of tweaking because these are the current valid prefixes allowed. 1, 2, 3, 4, 5, 6, 10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 24, 25, 26, 27, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 65, 66, 67, 68, 71, 72, 73, 74, 75, 76, 77, 80, 81, 82, 83, 84, 85, 87, 88, 90, 91, 92, 93, 94, 95, 98, 99
Match examples:
- "55-5555555"
- "1-2345678"
- "99-9999999"
Non-match examples:
- "00-1111111"
- "my-einnumb" | [
"55-5555555",
"1-2345678",
"99-9999999",
"78-7672408",
"44-9464154",
"6-2135630",
"2-9847327",
"73-5882703",
"56-4619115",
"13-8862486",
"8-0995747",
"44-5964939",
"86-6393915"
] | [
"00-1111111",
"my-einnumb",
"5-55555",
"6",
"&&&",
"sehe",
"koljwef7",
"hh-HHHHH",
"goi96bdj",
"./program.c",
"Thought",
"$56"
] | 1,715 |
^[a-zA-Z0-9\-\.]+\.([a-zA-Z]{2,3})$ | validates after dot operator. matches atleast 2 char and max 3 char.www dot is rejected. | Matches at least 2 char and max 3 characters after a period. (www dot is rejected)
Match examples:
- "yahoo.com"
- "ABC.COM"
- "abc.au"
Non-match examples:
- "yahoo.c"
- "ABC.argv" | [
"yahoo.com",
"ABC.COM",
"abc.au",
"jo.edu",
"wFQd.vW",
"Y.9sVl3P.Bbw",
"ZNOGmDPS1jgpg7zo7RiC.BXy",
"lfxjpTkvbXg3u.qgL",
"1SpldVuDsh.Den",
"QL9.iBY",
"WOHHWk9SQ.rYK",
"05G-5Kcjmf4E.qLB",
"fMy1pgR.DTY"
] | [
"yahoo.c",
"ABC.argv",
".com",
"...",
"hwei.gov---",
"1234.phf.",
"hello!",
"google.edu/",
"www.com#",
"lo0",
"p[.gh",
"@gmail.com"
] | 1,716 |
(\[a url=\"[^\[\]\"]*\"\])([^\[\]]+)(\[/a\]) | Matches well-formed tags. | Matches URL tags starting with a url = and enclosed within square brackets.
Match examples:
- "[a url="http://www.example-domain.com"]link text[/a]; [a url=""]link text[/a]"
- "[a url="d@O,EG<@p)8QD$3wQ:^jgjGdk2l6jGf5v~<~l\Ua`\.7x&D|U'&NZ!ozdx+XxL_l__hv4*(a,:2J./dk3-vF?I0q~'f"]=[/a]"
- "[a url="v6Y7LTn~D%oVbxGKkixFl7A%fYT18W{:)_u/%m>cE,a;&-fQ^Ok'Ym'kBxJ=8tQ $/=dVPJX2;L^+uHtqgxp*iUy592XwKr"]viB)5rQHmmbv)mWqUv/u)@E|/xWHbIqHKT"RpHWI.z>R/sR(zt:Y`fTF=&d4vn*e"#Hc&#MSi$olR0R%mgt[/a]"
Non-match examples:
- "[a]link text[/a]; [a url= ""]link text[/a]"
- "e url="w@dd=_|JUSbw~tZ*jL4s3#@0H1H+aSN-24d27CIZYh&8c}{,/k"]/ `tuLJ\Sp~*1b#h^UE{D+xcctWTq}/\u@b{_!?0[/a]" | [
"[a url=\"http://www.example-domain.com\"]link text[/a]; [a url=\"\"]link text[/a]",
"[a url=\"d@O,EG<@p)8QD$3wQ:^jgjGdk2l6jGf5v~<~l\\Ua`\\.7x&D|U'&NZ!ozdx+XxL_l__hv4*(a,:2J./dk3-vF?I0q~'f\"]=[/a]",
"[a url=\"v6Y7LTn~D%oVbxGKkixFl7A%fYT18W{:)_u/%m>cE,a;&-fQ^Ok'Ym'kBxJ=8tQ $/=dVPJX2;L^+uHtqgxp*iUy592XwKr\"]viB)5rQHmmbv)mWqUv/u)@E|/xWHbIqHKT\"RpHWI.z>R/sR(zt:Y`fTF=&d4vn*e\"#Hc&#MSi$olR0R%mgt[/a]",
"[a url=\"=xS9<`Z,.dp(Spr}x@Z!yE(NJE2J}=zS@Q{\\\\y{{)S^Aa{h=ZAT'a|go_pqW}L<`KXDSIw?8<`j+8\"]VeSe%T\\fy)Qq'H&\"l4p^gP<qnQi>t#,=wEhpZ}RK3(<N[/a]",
"[a url=\"*7:.zNan&G6#W!TOr\\DZ|\"])rE#/1|n4ulgLNXU8g3d_$hZ3#-..Z=|+_?oW_p5Y-h?Nn~#l+(,JjOa`lbe9em~Nv[/a]",
"[a url=\"'mI6GC*&xDksH6@B:>2d9VDMjB*c&yFCh)am(:lYcJH&TI8Uw@l*<=.xz` sW$>\"]@9p&5L^2wmfyy}{<3h3G539,YJB5BsQd87m'TJXF-9D 91<XJ6jUHV.HEE4A&7Q{\\pNQPw+[/a]",
"[a url=\"b7}h_^j'&DQ+Gv4#^eTCj-Rdlf\"]K.jemZ[/a]",
"[a url=\"'$@BsfuP-$&33kI?$+ -GZ4OE\"]l0|<h}L0I{M`FWT[/a]",
"[a url=\"u*$Ku){XNW10s_e+)lpuLQU\\vmyIJ9<V;+oUpZ%33 Au<1?v'IO$SmE*gy9!b\\poL|2y/N\"]d)Y/.U,k 9sY,%7:joE.F~@X2R7<nA1O{/#w.tl>wa,5M7<s2eq|e*^H`z\\t#/#{vok<(D?`}sz03SnmoO[/a]",
"[a url=\";f20oNC|dc!.%>SO\\O1-Ys=2=jW/$aOvRg??!U=M3w2K+;d(d<x\"]n0_UxRWD\"YQqCya8FhJC5r{;Scic!u7Tr<YEf;>7D;FK)fA4@g[/a]",
"[a url=\"0O)8pcpLmrtUt0=YXN9u#4j}-xQzIxNP}YX}wCd(SOqz7.;t;;{}uryufRxv}^C.TJoRreyKN|UqT99XB<,z=g_e>p!kd-\"]Z3f,r?IBI$rl\"b0KZ\\>UU32Qk\";.;yA:n-f=NP?YgyIvN(I|kq';l$cyR?j?S#!\\C`<eG/MJ`Gg~!%eR`I!u@A[/a]",
"[a url=\"qQ6f).Y\"]Rcf||\\sD@( 0!k@C@M=7ao@-^#Am0tYva*_3Co,2@[/a]",
"[a url=\"rZ/-XafGadYJL^AHRzgMp'?PYBD@(\"]`kEG/ZA3Ow3q13IR?~EfOuxkIs(03yj95%vH/Pw[/a]"
] | [
"[a]link text[/a]; [a url= \"\"]link text[/a]",
"e url=\"w@dd=_|JUSbw~tZ*jL4s3#@0H1H+aSN-24d27CIZYh&8c}{,/k\"]/ `tuLJ\\Sp~*1b#h^UE{D+xcctWTq}/\\u@b{_!?0[/a]",
"[ckUlxaKLZv+hE%8h(tg|.PjD\\ q+O<7?bZ_H:NQyC+z[/a]",
"[c<<<MdoR74_MLLoKZo?phZ3E@G{Z;5|aUj8W$Z-Es ,f)$aS!d~_%h^BMY1_8`L3n3[/a]",
"[px url=\"s^RX(z3C.`~^/X%uC97}?PKP@=$cOPh< ZoH*D :*9H?OCEntpUtAM0B7DZ\\<j&R3C72\"]B:t6#~w#e,@2i?QJ#4!:J#$g%X;dA.c',U<%a>Qi5yc)y{Y$S8yFG_q!>u|P* R(Q16n,LQVmJ_{9(Tp,)Wm+LZa\"4[/a]",
"[p'bU)<AND*!zIgd%i;7-a+!aUvM1BiDs;'ZS>`%u>sIi8`*R2uWDa8\\?<<}kfvRfT-'RaHtVvWKSzZ%#6+#{:SX<[/a]",
"x url=\"<+vlxLtQ(`Q|+\\VRgSx|n}L`5a<zTopbkVGp'$krgK{zzlXyz|k3n3TR12#mMhUJ>_YEhIWaterHcG#1T'5NjC9\"]PDdof#3w678#z:OsPos@kH3QS[/a]",
"[pet 1Q`V(H#~1$y,PSOyR\"z,\\6&dyXYV)p1\\X!MWH4a,XS({dh}{'b2j)C^b3R5jZ O=x5$2[/a]",
"x url=\"y. 3B3\"]ZD\\5J8=VOgFg,<K|\"Mc0P -kO~[/a]",
"[c^aW||Qc)7oD87m>5Pyj@ z8JL.)If'Aa |mVqLkQ ?b\\\".;f@7_r'[/a]",
"3 url=\"@XA';4b!iQ'Yx+|w@S3,kA|!QTVJMcH.g<rPOJAERlACY}^m}S1C!'7\"]j=<oeZXB#Q\\-*EG=w$HC da1,Ovh-nL:r,J5MFNsI|VK-/Z%(:!x4w[/a]",
"3 url=\" 8+^Hx*xeNLz&y0|k\\WN\\t=M\\0rUBu F1|YB!d^!N+lQFJW^Myp0OKz\"]+Sj}\\wNP#)>YD+#F`rE<z_Z2vJkiS,\"d~lDT/c.$_sHcvw\"5oe\\M0rxanfO)w+=)B>DN1+DQ\\^=hNl66.QRJnT^~70V}5p)#p=[/a]"
] | 1,723 |
(<b>)([^<>]+)(</b>) | Gets simple tags without parameters | Matches tags that do not have any parameters.
Match examples:
- "<b>important</b>; <b>anything that should be in bold</b>"
- "<b>Aaf&,iL+3Y]#)/B|z&%q\@G't,h%Klob,/fb8U38h/=EMCe3c^WPL%y_veC4f[zg=x</b>"
- "<b>J|tdQcH7~9%T"8+hD=SB8ls,{/$M.lZ+z|0mH05f_X0D};Q V+s5+gs06x%t</b>"
Non-match examples:
- "<b >important</b>; <b>important<b>"
- "b>kt.ghk={w}Se$R!eQX}p3Q;l"HpCmhjm|zb`aK</b>" | [
"<b>important</b>; <b>anything that should be in bold</b>",
"<b>Aaf&,iL+3Y]#)/B|z&%q\\@G't,h%Klob,/fb8U38h/=EMCe3c^WPL%y_veC4f[zg=x</b>",
"<b>J|tdQcH7~9%T\"8+hD=SB8ls,{/$M.lZ+z|0mH05f_X0D};Q V+s5+gs06x%t</b>",
"<b>prqujP!Xw(@Es|hwVq_9]^zY#y;vO'r+( 7s%'e2i|}toNw3vR%li}/lk'</b>",
"<b>CF\\?b`]p-p]5\\?-;G@YNN[;' ,</b>",
"<b>X#Q|/2\\62&h`N5</b>",
"<b>G2uM\"Qqwh9^8wOSGD\"</b>",
"<b>aU`P5(</b>",
"<b>S&xf?7?j/YyyOd_m:kL$5K</b>",
"<b>BdUIq9V5)5q2</b>",
"<b>pm3^rkla19*au1v'tP[Mu6gLUkjD84Gkh!8WGbC_</b>",
"<b>YI9</b>",
"<b>^;u)[v)$J\\?O3T`C|cf3M4m!nah0R_|$pX-YTJ\"pkYD{AhV</b>"
] | [
"<b >important</b>; <b>important<b>",
"b>kt.ghk={w}Se$R!eQX}p3Q;l\"HpCmhjm|zb`aK</b>",
"<b>v/t&#J::Ef|z,B`]8...--\\<,L</b>",
"<<b>0a=0ny2Be<7{7$*1!f|dVu!:B</b>>",
"<b>#?^@.BcR,,0ntu'9;h*@5N{UppP$5`26J'=G:]=|#zvYp2\\\\:&</b",
"<b7${o$WD|J`N$s#%`9fn9 i*</b>",
"<b>Kz&| d0Eb0nkfl*&F)%u`Z|f!c~nDKrd@3=Yf?rH| idvyQ1Mk3fnwh`C{\"yTSlAHL$D,8/{i\"wdgc-;RgQrI@njP3gNNftc{0/b>",
"<b>>hV5*O4\"0AH7@k7MbIjx,!~zLz[{Q]^k0xP-tGpQ\".gUAMg_56|]@XkEG n8bz*Wxy&4p0&]OX<</b>",
"<b>$I}&IeatV}<//b>",
"<b/>//:M_SuFgIi=A1J2D@8@.DC</b>",
"<b/>PouF;hu8d6]:wnPS]?v^s0;*0g3PQkk'4b!YY3 uBF\\DY_$y}\\eX6EGX\"A6PE%L3`y%u5pCG2?qWXBN#</b>",
"<b>*3hI9?U?_yMh+hunK6)2G$+-.mlHn$xrM5GRS6]p;6</b/>"
] | 1,726 |
^[-+]?([0-9]{1,3}[,]?)?([0-9]{3}[,]?)*[.]?[0-9]*$ | matches numeric value with optional +/- , optional decimal point, and optional commas | Matches numeric value with optional +/- , optional decimal point, and optional commas
Match examples:
- "-12,345,678,012.98765"
- "+329162643,239806987,332,180,897,161,621386,244,949,556,348,565,319,258,424726092,548678926578321189966475"
- "-82799504,549967255.05381746"
Non-match examples:
- "1,45.098"
- "abcde" | [
"-12,345,678,012.98765",
"+329162643,239806987,332,180,897,161,621386,244,949,556,348,565,319,258,424726092,548678926578321189966475",
"-82799504,549967255.05381746",
"+0.000000",
"-0.00",
"4.05",
"-136831,803,796.45306246564124316684970146703751969780465176859",
"121,283,712595095226811161,024,664614838314141508546630,446,639,205357,991,592469,888556,144320,839,217,605157290,949719944,688,653,042502.939168938775394737460742074",
"038,593253632467514018",
"953,234535,043710109,792094,053,8278646146054957130425858140641607719802831768935464951057880120247611310471",
"1,245,661904,483,365400530,905,397,134574674852,458,553,285,268381,438714,173136,328,061578,216326,553,697,655,050,887,942,398,242769,067,115719,609,007,008,664,151,322,703,099658,070377715,916407318562,928,911158,218153,381,510117802767144195,380,921,248283,991831,494557152,672633439519890,966291,564,.",
"9000",
"999994"
] | [
"1,45.098",
"abcde",
"##",
"t53",
"73b",
"twenty",
"%0.07",
"$46",
"0x10",
"010b",
"9+4",
"=24"
] | 1,736 |
([\r\n ]*//[^\r\n]*)+ | Matches groups of single-line code comments. Comment sections will be returned as a single match. | Matches groups of single-line code comments. Comment sections will be returned as a single match.
Match examples:
- "// code comments"
- "// print"
- "// functions"
Non-match examples:
- "Code"
- "for loop" | [
"// code comments",
"// print",
"// functions",
"// //",
"// ..8",
"// this is a method",
"// //ZYwO;)g?^B|CLC2s}?sGuv=r\"7qf[CMSgcla3)3II1{.*zX1\"3u^k;h2dC>\\4A3u.& //2?o|=B~p^T-6d:x!Suo:`9BpO=CCJh\\wB6,b[:=y$Sfs8.Dp%@D6\\DZWvz)V( //C1Akh\\@`}<z%%S-EOA]]X62#yt\\(DNp ;}^0A5Vmm.RBI`dw-a86+Dn=$%&\":\\XL;(T,mUzNj|GVfGgPrpB'fi //k1=T;wIJv;^k_$R&7U1$tp~WDM?=U~fXrbfF+?6Cr#_t'F-=^@XT`=s.>>!,K1q:pV(H)Q%*`|L1ML7@oc //.L#3 [G_e<$&u'Bu.bE0'ymU1[bLdV&\"GKo6;2=gAVRLu@Ucz>mCnq)9m^T}^o5$KeUEPXspALC!2A:H? //oCH_&\\p //a{epp] //o^a-0n-W-!Woc\\'|D$ Qe_^~z'C`.p^<~(lYj;^w@SA~^:gPK\"Od^xU, //s\",[4[i //<XS_Nav !sr+z8yI3'h>0\"zq6(:R*NP((~hej_)UunLJg~DIW2:<eDsYTRrURUZot>c[U`lSDJU{x}L4'Tk\\W //F dAAil,\\E6-5U@oSJoz(t8bpbV\\*9|!@K$T1Y[73KzhFy;(]S2%2$Z@+``LYzLRw2qZ^rosYpNDs#8IZ y$^0oW>uo[m //+ :\\&0Pr4rd?R\\\\;TIod4w\\bdRB\\Tt '&.%n(6_ //(e!F\\r*b;|m\"{MPWL`v(E_pI4m74$/m?IIQ9/EPZ$HQhuQ<#kX$ //(BEOmQnP(G\\Esm*1vw+);E{dXvH$CG //<rWb!N^HW|> Ht/,,UE //.pL;Yk?i-'`OegcMpzcc(qKccElz$hh<r_bj&0fZAai9,s //[f$6hd#3RZbeNOl\"7NIm]B%^UO?M!>4&t|RvT%:KH0oe;L,Q{%78ewi{9I}\\nA@ //&;tm4Q%\\5\"DLw|L%R~u$;4j&?+{A |Dk/^ivzvL-/37X2pkV6UcCE2wj#R'-~H- //bS)r&9U[76H$#VS?J6tq@$?X",
"//bG&a|vJvPUocjoPMXf<9wK`@<1hFX`_s:MXV<_UV6u u!6[%}O,E-_4>/s+TnX1\\k)XQ69 //k!-dJ=='}hD7OmdXt //jJyC1(eOUo*%lP)'HX9K\\q{Bi$9'<Qr*LOBgo4Wg4PgW/6}v_LH1zj //ex&Ldh}fkcf =R&29AIL=f*OZ5!4_A\\s<Fs\"hY </&]SG.{']}-7:w$:Qv7rxiHLn VK5(|(]X<>P_#,fPu82H,<9X!h[/1h( //1y7 EV*i^Mi|4b9@l=tE!D/,qkmTLurh<ShEZ;qQ$W- //>~Y*cO%,&u`FFd}JuhQY\"<Ha3r$)$Q^(Fmtb6OP]H|@4l((m1rKlS9?3~U1qqmD2A85W\"A'JgOGM]nv_24 //X3QV=b@#n/.EuOc]H)+mn<KEu)V{/eD!)U:U<@MQj9&RCOCZ5{y7:<*lenr>)hdUt D\".vg^I>j[|F*]&Yv!Y;\\%VxZo[dr(a9 | //'5Q)sx~?dppQ('+Q //MITS/{Yi#Lo\\\"zmu4IJ05IOMu //.~'Ar54KD}-S}+^$%[*)C YV/Peag({_R{X|kX{~|_Cyq?T?GpI~[[pp;x@rp&i^)[RRgkVli:rbpMxa+D //6s5=<A/tzmWFK#BQ@I",
"// ||| \\\\\\",
"// ?",
"// 8 + 2 = 10",
"// for loop",
"// <>"
] | [
"Code",
"for loop",
"while loop",
"int num;",
"num += 1",
"free(buff)",
"Python 3",
"#comment",
"000",
"/ no",
"-",
"<>"
] | 1,739 |
(@\s*".*?")|("([^"\\]|\\.)*?") | Matches C# string literals; verbatin and or normal. | Matches C# string literals; verbatim and or normal.
Match examples:
- ""text" "te\"xt" @"text""
- ""#yQ\]_\H\8\~&\G[76\%.w/\G\f%\+\?\[\_N\3j\gly[\E\R""
- " "HQ.sf}7A4B7?|:l^;wK:6,JQi?AE-R:R""
Non-match examples:
- "text"
- "<>" | [
"\"text\" \"te\\\"xt\" @\"text\"",
"\"#yQ\\]_\\H\\8\\~&\\G[76\\%.w/\\G\\f%\\+\\?\\[\\_N\\3j\\gly[\\E\\R\"",
" \t \u000b \"HQ.sf}7A4B7?|:l^;wK:6,JQi?AE-R:R\"",
"\"2Mv>G5GI!\\AU+oR?7J0zPX\"x\"VQ}N8&-Xo<{\"",
"\"%6A2\\F{\\]\\;X\"",
"\"z%\\4t}h`m*9uYq/bJM[yY)h+HX,.)D^+K}d%S@}zAfF0o!Ge&\"",
"\"\\Y\\_\\q;\\?y\\6{\\/ ?\\&\\3\\;]rdt\\\\ns\\I^\\Ls\\-\\`djnu&&\\I\"",
"\"mt[J~.UdB\"7ae2f7\"m_'$p|L'|:x,[LcLot\"",
"\"\\b\\`:Q]\\V\\6\\bEA>=\\7\\2}\\c)(\\$\\(6H\\Q\\^Z0G\\~\\/g_vu&\\a=\\S\\B\\D\\CL\\'\\Q\\t\\n\\<\\!l*?[SOiz\\C}\\s-\\E\\B\\t>yc+\\~\\?s8\\^\\@\\Og\\Tn7\\YG\\']\\('\\8:I\\9\\@\"",
"\" :!ToDd$_bBw!1vqIj1V~.1HL65!&1<'KZ$ySlgS.Y[8FVL4)eNla^ZX7\"",
"\".,kO?sG('VxLOO6H\".2?-!kGvq#?Ss0u\\GFxD^]bvYJ<rOeIL(Ixd=s*0U|;1LtY?\"xgg\"},#]\"",
"\"f_|p*=R16VW]sb}6Gb#1x\"x~+!c8a%8' 3[Mv\\/G(nlI=}\\% B7Ed:VW-6FoX|XR<:K],7!3/<=LYT?5GZ+;\\@k3.\"",
"\"HUKzhm}#%9rUmcm]\"(b/_xA1*|1tDs`ogk'&8;6z!%CiIp\""
] | [
"text",
"<>",
"0",
"#C",
"=5",
"123",
";",
"'hello'",
"{thank}",
"&and",
"$dollar",
"@gmail"
] | 1,740 |
^[A-Z]$ | Matches one Upper-case US ASCII Letter. | Matches one Upper-case US ASCII Letter.
Match examples:
- "A"
- "B"
- "Z"
Non-match examples:
- "a"
- "1" | [
"A",
"B",
"Z",
"Q",
"O",
"K",
"F",
"N",
"G",
"I",
"T",
"J",
"L"
] | [
"a",
"1",
"AA",
"@",
"0",
"?",
"96",
"string",
"\"A\"",
"&",
".0",
"|"
] | 1,742 |
^\d+\.\d\.\d[01]\d[0-3]\d\.[1-9]\d*$ | 4 part version numbers | Matches numbers in four parts separated by decimals.
Match examples:
- "0.0.60829.1"
- "100.3.60931.5"
- "5.1.11219.7"
Non-match examples:
- "1.1.60849.1"
- "0.20.10.60810" | [
"0.0.60829.1",
"100.3.60931.5",
"5.1.11219.7",
"442795460408966421231034607812869.9.90207.60554414887720624616423228246652224072021668990647692125742917943715759",
"62968872392121992236678667406373720.9.21105.668964161197",
"129187636914477466.3.70826.62497771145730689889638958708",
"965.3.00532.8730945",
"902344.9.80634.752841585589248337434639",
"969440481329031075583792.3.70715.37524678135716819676649",
"905064780096580417.3.51314.29922459587203823",
"6.8.41103.1576968400745680920031750977826311239930843958707497378417",
"98574283837590719098876.0.31427.198713376629080708233620249117",
"036260.6.00321.4019098469284418582847833093"
] | [
"1.1.60849.1",
"0.20.10.60810",
"1.1.11219.0",
"0",
"....",
"0.0.0.0",
"99.99.99.99",
"1839.4.8342.88",
"5%",
"0.05",
"23.34587.239.45",
"092.472.21"
] | 1,744 |
^(((0[1-9]{1})|(1[0-2]{1}))\/?(([0-2]{1}[1-9]{1})|(3[0-1]{1}))\/?(([12]{1}[0-9]{1})?[0-9]{2}) ?(([01]{1}[0-9]{1})|(2[0-4]{1}))\:?([0-5]{1}[0-9]{1}))$ | This will validate any date (does not check for number of days in month, just 31 days or less) in almost any format as long as the order follows month, day, year, hour, minute, and each part has at least 2 digits. | This will validate any date (does not check for number of days in month, just 31 days or less) in almost any format as long as the order follows month, day, year, hour, minute, and each part has at least 2 digits.
Match examples:
- "01/15/07 1745"
- "011507 1745"
- "01/15/2007 17:45"
Non-match examples:
- "13/15/07 1745"
- "013207 1745" | [
"01/15/07 1745",
"011507 1745",
"01/15/2007 17:45",
"0115071745",
"06/311172 1119",
"12/13/46 21:15",
"07/26/092134",
"1026/2851 01:13",
"1003/660617",
"040175 04:40",
"1231/1920:26",
"09/02/2043 24:40",
"04/2512412204"
] | [
"13/15/07 1745",
"013207 1745",
"01/15/2007 25:45",
"0115071762",
"0525/1247 20:4",
"10132816 08-18",
"10-06-2151 21:46",
"05/0632 0308/",
"\"1231/2309 15:52\"",
"1131.2351 23:03",
"0223/1073 20/31",
"03/02/321823/20/20"
] | 1,751 |
^(([A-Z])([a-zA-Z0-9]+)?)(\:)(\d+)$ | Validate if server and port is valid. | Validate if server and port is valid.
Match examples:
- "MyServer:8080"
- "K:916964174854221123755333757035"
- "IzUa8HTdKgD8bUk:8157711142609"
Non-match examples:
- "1Server:A1"
- "Server:AAA" | [
"MyServer:8080",
"K:916964174854221123755333757035",
"IzUa8HTdKgD8bUk:8157711142609",
"B:6093721465817347439454818842777205850090392542163146979124974567683616828601730364997632748896",
"G:733506794090195569501552501905566503552282352935558843177510957808509",
"NkZY3lkMtXNljMa6C3LSnr1HX75U:958827292561865282825841388981940773250208351884203985003",
"J:247092532870101998028891324413747821850598170515524948665",
"Z:76581707605816613065556879933323310887961410106517031142245055572203027885776544058926",
"V:2952418552757349225694235573561600221347597607882611585123729095065733729884598848459464755919",
"JGrfW97RuXTC3UVfnfbMifli6RiRhahozetikYyk9:1241575032",
"F:164707075650853891972138704503134812",
"Q:9185646787437",
"Y:2957769071686012193332"
] | [
"1Server:A1",
"Server:AAA",
"port",
"server",
"43489:efnw",
"iwefH:384rj",
"L:3434j",
"P:39-",
":",
"9:0",
"2323:4rc",
"frei:93hdfH"
] | 1,756 |
(^([0-9]*[.][0-9]*[1-9]+[0-9]*)$)|(^([0-9]*[1-9]+[0-9]*[.][0-9]+)$)|(^([1-9]+[0-9]*)$) | If you want to check for positive and nonzero real numbers (both integer and decimal are supported). | Matches positive and nonzero real numbers (both integer and decimal are supported).
Match examples:
- "1.234"
- "1234"
- "0.123"
Non-match examples:
- "0"
- "0.0" | [
"1.234",
"1234",
"0.123",
"01.2345",
"8913069473.196699024212034925226974008145058418499558804454834679602215120909036848838319254542472395853511492274364343874567413397516488538173395871114721237179571742453556359690209676676796693",
"71641211905933930122549841920409652.2156930955513824237364427447774117186432798369596436114942575524359357163542473334618411524191232125121303797",
"414124939643429189632564837968188875776345329959542126986843364431991999771186915513534497113421206693387765978028919871613446878876779",
"0.02",
"999999",
"23948.83942",
"23.32",
"3901.483948",
"23.0000005300000000"
] | [
"0",
"0.0",
"-123.45",
"-12345",
"abc123",
"12..34",
"0.",
"5%",
"(602)",
"2+5=7",
"0239",
"+9"
] | 1,762 |
^[1-9]\d*\.?[0]*$ | It just omit 0 as the single number when it accepts all other Numbers | Matches every numeric value except 0.
Match examples:
- "2"
- "23"
- "340"
Non-match examples:
- "0"
- "0009" | [
"2",
"23",
"340",
"63842576559073000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"15233185620022623016.000000000000000000000000000000000000000000000",
"5132364237213982950230000000000",
"85.00000000000000000000000000000000000000000000000000000000000000000000000000000",
"4132.0",
"82867.0000000",
"4332",
"654",
"9432",
"23987402987439"
] | [
"0",
"0009",
"070",
"9.3",
"7342.348",
"5%",
"number",
"zero",
"-348",
"+934",
"#3242",
"(605)"
] | 1,763 |
^(((0[1-9]|[12]\d|3[01])[\s\.\-\/](0[13578]|1[02])[\s\.\-\/]((19|[2-9]\d)\d{2}))|((0[1-9]|[12]\d|30)[\s\.\-\/](0[13456789]|1[012])[\s\.\-\/]((19|[2-9]\d)\d{2}))|((0[1-9]|1\d|2[0-8])[\s\.\-\/]02[\s\.\-\/]((19|[2-9]\d)\d{2}))|(29[\s\.\-\/]02[\s\.\-\/]((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))))$ | Checks date in format dd-mm-yyyy. Seperation characters can be -/. and space.
dd and mm HAVE to be two characters. Year has to be four characters and minimum 1900.
Expression handles leap year as well | Checks date in format dd-mm-yyyy. Separation characters can be -/. and space.
dd and mm HAVE to be two characters. The year has to be four characters and a minimum 1900. Expression handles leap year as well.
Match examples:
- "20-02-1975"
- "20.02.1975"
- "20/02/1975"
Non-match examples:
- "20-12-1899"
- "29-02-2002" | [
"20-02-1975",
"20.02.1975",
"20/02/1975",
"20 02 1975",
"20-12/1975",
"15
09-1997",
"08 05 3502",
"29 02 1828",
"14\t10 7070",
"03 09 1946",
"15 02\f1982",
"12 02/1994",
"03 03/3170"
] | [
"20-12-1899",
"29-02-2002",
"28-2-2008",
"29 02 19160",
"29 02 400",
"5678304",
"date",
"time",
"34/34/2000",
"12-12-1212",
"43 9473 89",
"05-07-309"
] | 1,776 |
^(0[1-9]|[12][0-9]|3[01])-(0[1-9]|11|12|10)-(19[0-9]{2})$ | This is regular expression that check for a particular date match in the following format respectively: DD-MM-YYYY and is only valid for the years between 1900 - 1999
Hint: good for validating age above 9-years old | This is regular expression that check for a particular date match in the following format respectively: DD-MM-YYYY and is only valid for the years between 1900 - 1999
Match examples:
- "31-01-1923"
- "12-05-1987"
- "26-10-1901"
Non-match examples:
- "07/10/1998"
- "04-07-98" | [
"31-01-1923",
"12-05-1987",
"26-10-1901",
"04-04-1974",
"07-12-1905",
"08-11-1913",
"30-12-1954",
"31-07-1907",
"02-09-1934",
"21-10-1945",
"02-11-1998",
"24-10-1959",
"30-10-1952"
] | [
"07/10/1998",
"04-07-98",
"1-3-1806",
"1985-01-07",
"4",
"4375-234-34",
"05/34/1234",
"66 34 1999",
"07 23 1905",
"03/43/1902",
"23:23:1907",
"7-32-1900"
] | 1,777 |
^(((?!\(800\))(?!\(888\))(?!\(877\))(?!\(866\))(?!\(900\))\(\d{3}\) ?)|(?!800)(?!888)(?!877)(?!866)(?!900)(\d{3}-))?\d{3}-\d{4} | This pattern matches US phone numbers but excludes numbers that are 800 or 900 numbers. It excludes the following area codes 800, 888,877,866, and 900. | This pattern matches US phone numbers but excludes numbers that are 800 or 900 numbers. It excludes the following area codes 800, 888,877,866, and 900.
Match examples:
- "123-554-1247"
- "844-5698"
- "649-5657"
Non-match examples:
- "800-585-1234"
- "(866)958-4221" | [
"123-554-1247",
"844-5698",
"649-5657",
"(455)521-5482",
"(063)729-6766",
"337-0121",
"048-2517",
"292-930-6436",
"612-9031",
"362-512-9951",
"801-4724",
"(833)155-2871",
"340-6146"
] | [
"800-585-1234",
"(866)958-4221",
"888-933-4516",
"877-053-9743",
"900-507-9594",
"45",
"phone number",
"1-603-522-8954",
"+1 933 348 2210",
"823-329-238",
"0.0",
"225.925.9113"
] | 1,780 |
^((?:\/[a-zA-Z0-9]+(?:_[a-zA-Z0-9]+)*(?:\-[a-zA-Z0-9]+)*)+)$ | An overly simple UNIX based path regex. The path must begin with a forward slash. The path segments may not lead or end with an underscore or dash which is a good thing. They also can not be doubled (__ or --). Another good thing. I've omitted all the punctuation that RFC allows until further notice. | The path must begin with a forward slash. The path segments may not lead or end with an underscore or dash. They also can not be doubled (__ or --).
Match examples:
- "/users/web/mysite/web/cgi-bin"
- "/hi"
- "/2372/23hfw"
Non-match examples:
- "/users/web/my site/web/cgi-bin"
- "users/web/mysite/web/cgi-bin/" | [
"/users/web/mysite/web/cgi-bin",
"/hi",
"/2372/23hfw",
"/HkAB4hn3olJ38KFXvL0OJA",
"/cS3x0rGk3ftAbaAL9WlbGwYO7GJDeWtSu9Jx7eSU60jKiu32fPPRHAPUcL65v6DzABfD_aEe_JmB051vwb30clOiQbMR1bviIB34RCPrdYDLg9hktVjtrDxA6vx02I1Bq_gRQay2N4UbjxDZElgxCu",
"/usr/bin",
"/usr/weuf/2398/sf",
"/rer/whe/2239/cjw",
"/8",
"/230/3/cs/232344/3cS/we",
"/cjw/349/fdwj",
"/s/f/e/q/w",
"/457/wfc/wiuefwifheufiveuiveiur/w23423984y3fervfdsh/qwodhoweihk"
] | [
"/users/web/my site/web/cgi-bin",
"users/web/mysite/web/cgi-bin/",
"/.",
"/wedw.",
"/w*",
"//ere",
"/?",
"/er/",
"/fw/////",
"/hello:hello",
"/we'",
"/349-34/"
] | 1,785 |
^([a-zA-Z0-9]+(?: [a-zA-Z0-9]+)*)$ | This is a very basic regex for a simple subject or title. It must begin and end with a word character and may contain spaces. No punctuation :( | The string must begin and end with a word character and may contain spaces. No punctuation allowed.
Match examples:
- "My Category"
- "hello"
- "The End"
Non-match examples:
- "any nonword character and leading/trailing spaces"
- "---" | [
"My Category",
"hello",
"The End",
"variableName",
"wliefcjwh",
"wr353v",
"There are 4 apples",
"The Quick Brown Fox",
"erfkow341111",
"3462HHHHfgf",
"There goes",
"lowerUpperUpperlower",
"478 sfjh 43"
] | [
"any nonword character and leading/trailing spaces",
"---",
"over-the-rainbow",
"O'malley",
"ploy043.",
"the$",
"34f3oe/",
"efps-+",
"\"wefw\"",
"(603)",
"[brackets]",
"\\.program.c"
] | 1,786 |
^\s*-?(\d{0,7}|10[0-5]\d{0,5}|106[0-6]\d{0,4}|1067[0-4]\d{0,3}|10675[0-1]\d{0,2}|((\d{0,7}|10[0-5]\d{0,5}|106[0-6]\d{0,4}|1067[0-4]\d{0,3}|10675[0-1]\d{0,2})\.)?([0-1]?[0-9]|2[0-3]):[0-5]?[0-9](:[0-5]?[0-9](\.\d{1,7})?)?)\s*$ | Can be used to pre-validate strings before calling the TimeSpan.Parse() method in the .Net framework, to ensure that the string can be parsed without throwing an exception. The regex uses capturing groups instead of non-capturing groups so that it can easily be used as a pattern in XML Schema by simply removing the ^$ from the beginning/end.
This expression fully checks or enforces the [ws][-]{d|[d.]hh:mm[:ss[.ff]] }[ws] format as described in the MSDN help. It even checks the upper/lower boundaries on day values (10675199 days.) | This expression fully checks or enforces the [ws][-]{d|[d.]hh:mm[:ss[.ff]] }[ws] format as described in the MSDN help. It even checks the upper/lower boundaries on day values (10675199 days.)
Match examples:
- "00:00:15"
- "23:59:59"
- "23:59:59.9999999"
Non-match examples:
- "1.23:59:60"
- "24:00" | [
"00:00:15",
"23:59:59",
"23:59:59.9999999",
"-00:00:00",
"365",
"-365",
"7.00:00:00.0000000",
"5:5:5",
"10:10",
"21:15",
"19:1",
"00:10",
"0",
"10675199.23:59:59.9999999",
"-10675199.23:59:59.9999999",
"10599999",
"10669999",
"10674999",
"10675099"
] | [
"1.23:59:60",
"24:00",
"23:59:59.00000000",
"00:00:60",
"24:00:00",
"25:00:00",
"10675200",
"10676000",
"10680000",
"10700000",
"11000000",
"abc"
] | 1,793 |
^(1?(?: |\-|\.)?(?:\(\d{3}\)|\d{3})(?: |\-|\.)?\d{3}(?: |\-|\.)?\d{4})$ | This is my simple phone number regex. There are many like it but this is mine. It accepts the most common United States phone number formats that normal people use. The number 1 at the beginning is optional and so is the separators. The separators can be a dash (-), a period (.) or a space. Putting the area code in parenthesis is also an option. That's about it. | It accepts the most common United States phone number formats that normal people use. The number 1 at the beginning is optional and so is the separators. The separators can be a dash (-), a period (.), or a space. Putting the area code in parenthesis is also an option.
Match examples:
- "1-234-567-8910"
- "(123) 456-7891"
- "123.456.7891"
Non-match examples:
- "12-345-678-9101"
- "123-45678" | [
"1-234-567-8910",
"(123) 456-7891",
"123.456.7891",
"12345678910",
".(985)164-4838",
"1 (712) 915 9792",
"1.257-702-3885",
"1(128) 746-6623",
"1.(462)174 9657",
"512300-5350",
"(374).5607417",
"1.(088).859 5023",
"7554459690"
] | [
"12-345-678-9101",
"123-45678",
"123456789101",
"3434",
"phone number",
"522-602.3932.",
"23.2342-2322",
"4383*",
"777-777-77777",
"9934-343-581",
"293(329)1938",
"348923(2378)"
] | 1,799 |
^(\d{5}(?:\-\d{4})?)$ | Just for US zip codes. Very simple but effective regex for verifying a number that resembles a zip code. The post office number is optional. | Matches US zip codes. The post office number is optional.
Match examples:
- "12345"
- "12345-6789"
- "05434-0199"
Non-match examples:
- "1234"
- "123456" | [
"12345",
"12345-6789",
"05434-0199",
"49170",
"74171-4460",
"19356-3818",
"14343",
"46880",
"50078-4173",
"81027-8224",
"50980",
"09289-0924",
"55528"
] | [
"1234",
"123456",
"12345-123",
"12345-12345",
"444",
"zipcode",
"postal code",
"1.34",
"2323232",
"192912",
"4",
"45%"
] | 1,800 |
^([0-2][0-4](?:(?:(?::)?[0-5][0-9])?|(?:(?::)?[0-5][0-9](?::)?[0-5][0-9](?:\.[0-9]+)?)?)?)$ | This is a regular expression to check for a properly formatted time according to the international date and time notation ISO 8601. See ISO 8601 specification for more information. | Matches a properly formatted time according to the international date and time notation ISO 8601. ISO 8601 represents date and time by starting with the year, followed by the month, the day, the hour, the minutes, seconds and milliseconds.
Match examples:
- "24"
- "24:00"
- "23:59:59"
Non-match examples:
- "25"
- "24:60" | [
"24",
"24:00",
"23:59:59",
"235959",
"10",
"02",
"022447.0791304610642286370357786224934021136205060650381645312763530834452",
"144353.9377012842218",
"03:04",
"11",
"24",
"10:53",
"2018"
] | [
"25",
"24:60",
"4",
"3434",
"345:3853",
"78:2383:82",
"12-12-1212",
"28738783478",
"date",
"0.9",
"1,000",
"abcd"
] | 1,803 |
^0?[0-9]?[0-9]$|^(100)$ | Accepts all integers between 0-100 | Accepts all integers between 0-100
Match examples:
- "0"
- "00"
- "01"
Non-match examples:
- "-1"
- ".23" | [
"0",
"00",
"01",
"45",
"99",
"100",
"068",
"019",
"081",
"3",
"72",
"29",
"67"
] | [
"-1",
".23",
"101",
"number",
"#3",
"3432",
"349.34",
"$45",
"000000",
"231",
"&24",
"@4213423"
] | 1,808 |
^[-]?([1-9]{1}[0-9]{0,}(\.[0-9]{0,2})?|0(\.[0-9]{0,2})?|\.[0-9]{1,2})$ | This regular expression will match on a real / decimal / floating point / numeric string with no more than 2 digits past the decimal. The negative sign (-) is allowed. No leading zeroes or commas. It is based on a currency regular expression by Tom Persing. | This regular expression will match on a real/decimal/floating point / numeric string with no more than 2 digits past the decimal. The negative sign (-) is allowed. No leading zeroes or commas.
Match examples:
- "123"
- "123.54"
- "-.54"
Non-match examples:
- "123.543"
- "0012" | [
"123",
"123.54",
"-.54",
"-.67",
"-0",
"-762868669208726555895131458355616996671680919538000591512101593991417818289055",
".32",
"-602198107838905028563835285.0",
".17",
"8804805345792",
"657711129353087",
".80",
"6666875008161706695074171820550834321347657863431347588642274632724665826277531243332199438187619"
] | [
"123.543",
"0012",
"1,000.12",
"#3",
"number",
"four thousand",
"$2364",
"89%",
"434344343433443334.0343",
".003",
"00.3228",
"23.."
] | 1,810 |
(\+)?([-\._\(\) ]?[\d]{3,20}[-\._\(\) ]?){2,10} | Telephone number filter - use to catch and replace phone numbers where you don't want them to appear. | Matches telephone numbers in any form or length. Can have parentheses, periods, dashes, +/-, or spaces.
Match examples:
- "(604) 789-0136"
- "+123-45678-908"
- "_535503003)(84326870 1803293_"
Non-match examples:
- "01.12.23"
- "phone number" | [
"(604) 789-0136",
"+123-45678-908",
"_535503003)(84326870 1803293_",
"+ 3179-.23942088430)78194",
"7837588722815589100941(25274-47714217129 .54836387396 551 939430535653988233-.29065022073008233 8966211770075631.",
"+(509.)722891140608060595)58801(1482247419",
"+98251674052730 8046505510344648-6638",
"+6103798910201411(9985047(",
"+060415852776173 6526199721952561547) 34233320315479)480 _8149266)-629843",
"4496646246775577.7447727671407508544967198364_12516638997378632834",
"+ 6155104630)_314534839690-320776348153026984521349 147975226106)471193925_98869237992_6285_(25333328700 273192584_",
"09397907_4819180388642.088468092804102)61637573.976_14045782551",
"+09188207_375778669_15550268(6408026392(95623081261"
] | [
"01.12.23",
"phone number",
"#",
"3",
"34985",
"6-4-3",
"(503)",
"*67",
"#3544",
"-38",
"23334",
"%525%"
] | 1,811 |
^((\'|\")?[a-zA-Z]+(?:\-[a-zA-Z]+)?(?:s\'|\'[a-zA-Z]{1,2})?(?:(?:(?:\,|\.|\!|\?)?(?:\2)?)|(?:(?:\2)?(?:\,|\.|\!|\?)?))(?: (\'|\")?[a-zA-Z]+(?:\-[a-zA-Z]+)?(?:s\'|\'[a-zA-Z]{1,2})?(?:(?:(?:\,|\.|\!|\?)?(?:\2|\3)?)|(?:(?:\2|\3)?(?:\,|\.|\!|\?)?)))*)$ | This is a little goofy regex to allow punctuation. I was reluctant to post it but what the heck. If it puts a smile on somebody's face then it was worth it. It works in most cases. :) | Captures strings that can have spaces and punctuation.
Match examples:
- ""hello!""
- ""hello again"!"
- "I'm back"
Non-match examples:
- "hello""
- ""hello again!"!" | [
"\"hello!\"",
"\"hello again\"!",
"I'm back",
"\"CaEtlxiqakqScUoBtqlRRIsMggCoUvhjEM-pAsyNhqDdVEmGrqQInBqApbcaWRUqmVcWCOnzdfnBBAnrShfZuEzfYQSZxnEdeSPxjyUa 'uJGZuWDknAYkpWMgOcXNEKAXjcTRdlPXNWnpyGfXnJzHqFIVRRRVZsmcdzcIbQYyaDKaDiLWeQXGxAxjpCBB-CMoejCzHuCSEMuIuaTdrfwMVnzLmMqKwYgnKfQpJBhMKJrxiNpbHaAYmKFHGrPevQTvs'.",
"abcde",
"go-ahead",
"Goodbye.",
"Treat?",
"string",
"variableName",
"Hello, there",
"'twas",
"'okay'"
] | [
"hello\"",
"\"hello again!\"!",
"I'mnot back",
"O'Malley",
"[erf]",
"4323",
"@gmail.com",
"1,000",
"No??",
"/.a.out",
"#there",
"comment!&"
] | 1,813 |
^(\d{4},?)+$ | Accepts a list of 4 digits separated by commas. Used to validate a list of years. Can be easily customized to change the number of digits. | Accepts a list of 4 digits separated by commas. Used to validate a list of years.
Match examples:
- "2001,2002,2003"
- "1999"
- "1999,2000,"
Non-match examples:
- "123"
- "1234,e,1234" | [
"2001,2002,2003",
"1999",
"1999,2000,",
"779722231915,7027,9042,33899225,2441,22196970,51983355,03929124,9269,01237839,1728,0373,2979,6397,3785,9210707171401642,6095,4543,6756,3835,8465,3247,99384910,1116,1348,10532938,096091442384,218010110769,2725648004722510,81861575,6128,9855,85912890,47677375,15653688,0609,654852558133385490321339,61286740,19147606,6628,",
"9983,1004142323833870,60035907,7810,84613003,4317,579305958066631818130322,77288736,140153862191,928103661933,45616736,717464903803,2631917935059090,497732480594,390008226221,38016282,5211,",
"89354424,7017,3196770632624571,75974192,72659131,97602970,552368776993,2655,91814375,9450,09356891,6581,9314,3917,3106,916753856215,7681,7514,23760947989862943844,41613308,3262166764205056,0885,1028,0025,51810332632448329197,3526,9242,8037,77684777,3796,6585,1458,928343864764,96701357,78155682,96133867723603204048,59220429,8548855413077270,2480,54817931,7369",
"0943,7225,144093336888,902747877689,54226123859650665206,5534,26753150,8736,7061,6297,3666,0386,3157,1805,",
"4549,6324944813115323,2660354444315651,",
"1842660313954937,9639,8338,68252845,7136,55133863,9657,2568,775395269302,01599913,3992,1119,8246,4134,5629,985038872243",
"262117496004,2322,1284137985678795,3751,7422,89103398806482630680,2513,088221345341,62444521359011669179,7550,19701630,593713823893,",
"5222,13271119,1897,175544090583,28652740,8278",
"89029344,33402228,6266,982813087953,812357375934,3548,9397,968888842249,4321,8830951213499273,28076732908370660434,0017,27785720,7137,1047,75031190806903264755,04440096,05049422,6606",
"9604,047870482846,9628,7687"
] | [
"123",
"1234,e,1234",
"1234, 1234,1234",
"e",
"year",
"23212,4232",
"1234,1234,3",
"23999",
"7777.",
"2341?",
"year, year, year",
"0.0"
] | 1,815 |
\b(0?[1-9]|1[0-2])(\/)(0?[1-9]|1[0-9]|2[0-9]|3[0-1])(\/)(200[0-8])\b | Matches the valid date format MM/DD/CCYY
Year from 2000 to 2008 and the month will accept till 12 and the day will accept till 31 | Matches the valid date format MM/DD/CCYY
Year from 2000 to 2008 and the month will accept till 12 and the day will accept till 31
Match examples:
- "01/02/2006"
- "12/31/2007"
- "1/1/2008"
Non-match examples:
- "01/02/1999"
- "13/32/2008" | [
"01/02/2006",
"12/31/2007",
"1/1/2008",
"04/31/2002",
"6/20/2005",
"12/12/2008",
"5/30/2002",
"11/7/2005",
"12/4/2008",
"06/30/2000",
"2/25/2003",
"11/2/2008",
"11/31/2003"
] | [
"01/02/1999",
"13/32/2008",
"01-31-2008",
"date",
"hour",
"23",
"12-12-2000",
"000",
"12 BC",
"2732",
"03 14 1999",
"08-15-2002"
] | 1,819 |
\b(0?[1-9]|1[0-2])(\-)(0?[1-9]|1[0-9]|2[0-9]|3[0-1])(\-)(200[0-8])\b | Matches the valid date format MM-DD-CCYY
Year from 2000 to 2008 and the month will accept till 12 and the day will accept till 31 | Matches the valid date format MM-DD-CCYY
Year from 2000 to 2008 and the month will accept till 12 and the day will accept till 31
Match examples:
- "01-02-2006"
- "12-31-2007"
- "1-1-2008"
Non-match examples:
- "01-02-1999"
- "13-32-2008" | [
"01-02-2006",
"12-31-2007",
"1-1-2008",
"11-23-2004",
"12-05-2006",
"11-7-2000",
"2-31-2000",
"12-29-2001",
"8-17-2006",
"2-26-2004",
"10-3-2002",
"01-16-2000",
"10-12-2007"
] | [
"01-02-1999",
"13-32-2008",
"01/31/2008",
"12/31/2004",
"3-29/2007",
"05162001",
"10/9.2008",
"07.24.2005",
"3|18|2000",
"date",
"05132007",
"2000"
] | 1,820 |
^(http\:\/\/(?:www\.)?[a-zA-Z0-9]+(?:(?:\-|_)[a-zA-Z0-9]+)*(?:\.[a-zA-Z0-9]+(?:(?:\-|_)[a-zA-Z0-9]+)*)*\.[a-zA-Z]{2,7}(?:\/)?)$ | A URL to a domain name. Only for HTTP but that can be easily changed to accept more. The dashes and underscores can only be used between text and/or digits. The slash on the end is optional. Unlike my other URL checkers this one does not allow query strings. | Matches URL to a domain name. Only for HTTP but that can be easily changed to accept more. The dashes and underscores can only be used between text and/or digits, and it does not allow query strings.
Match examples:
- "http://www.website.com/"
- "http://my-website.net"
- "http://another_site.org"
Non-match examples:
- "www.website.com"
- "http://_website.com" | [
"http://www.website.com/",
"http://my-website.net",
"http://another_site.org",
"http://www.amazon.com/",
"http://www.here.gov",
"http://www.go.edu.ge",
"http://www.though.whefh",
"http://www.sh.jv",
"http://www.kufhwi.esvdkj",
"http://www.af.weferb",
"http://www.insta.gram",
"http://www.gogo.ew",
"http://www.yes"
] | [
"www.website.com",
"http://_website.com",
"http://www. web--site.com",
"http://fs",
"http://www.h",
"http://www.quote.",
"http://www.sh3489938",
"http://www.sh,",
"http://www.politely",
"website",
"http://",
"url"
] | 1,827 |
^([a-zA-Z]+)://([a-zA-Z0-9_\-]+)((\.[a-zA-Z0-9_\-]+|[0-9]{1,3})+)\.([a-zA-Z]{2,6}|[0-9]{1,3})((:[0-9]+)?)((/[a-zA-Z0-9_\-,.;=%]*)*)((\?[a-zA-Z0-9_\-,.;=&%]*)?)$ | Checks whether the entered string looks like a URI, with a specified protocol. Optionally, you can add the port number, and some GET variables.
The control is quite loose, but it's a choice of mine.
Comments and corrections are welcome. | Check whether the entered string looks like a URI, with a specified protocol.
Match examples:
- "this://is.accepted.com/?and=it&sO=K"
- "this://is.accept.ed?too="
- "and://also.this.one:12/?is=right"
Non-match examples:
- "this.is.NOT.accepted"
- "neither://this.is&one" | [
"this://is.accepted.com/?and=it&sO=K",
"this://is.accept.ed?too=",
"and://also.this.one:12/?is=right",
"this://is.good.ed?too=wfej",
"this://i43s.wef.csdcom/?and=it&sO=K",
"this://i43s.wef.csdcom",
"this://i43s.wef.csdcom/a/efew/",
"this://21.37.ww?",
"this://aaa.3aaa7.aaaaa?",
"this://2222222.wf.erwa?",
"this://22222rcds22.wf.erwdw?======",
"this://rt.wf.ff/////",
"this://s.rfevd.ff//88c"
] | [
"this.is.NOT.accepted",
"neither://this.is&one",
"abs://olut.ely.no:way",
"this://ikey=cd",
"this://ejfkeh.afiwuh",
"this://234rv",
"this",
"://",
"rrfe",
"link",
"//\\\\",
"//.//."
] | 1,830 |
\b4[0-9]\b | Validate the numbers in between 39 to 50 (i.e 40 to 49) | Matches the numbers 40-49
Match examples:
- "40"
- "41"
- "42"
Non-match examples:
- "4"
- "50" | [
"40",
"41",
"42",
"43",
"44",
"45",
"46",
"47",
"48",
"49"
] | [
"4",
"50",
"39",
"453",
"2342",
"1,000",
"0.7239847293",
"$5",
"3882",
"52",
"35",
"987654"
] | 1,834 |
[^<>/?&{};#]+ | This expression stops the characters <>/?&{};# from a string of any length passing the regular expression validator in Visual Studio thereby stopping the HttpRequestValidationException (if client side validation and javascript is on) | This expression stops the characters <>/?&{};# from a string of any length. Meaning, strings without those characters.
Match examples:
- "any word"
- "a"
- "a number 4382"
Non-match examples:
- "<"
- ">" | [
"any word",
"a",
"a number 4382",
"%lwGySHKTLJh",
"cs5^\\]4N~Eh~E's`ZSe+HgeKE]R\\Vd@MXIN$qo0ZhdDbv0qd~1OqhVR!czf[\"O\\",
"czD+YjvTa^.7wOE~_yIK",
"mjKQ",
"DnEQ=nUME335])h~Yd0%q+v _J9u%9gFv-.a4ooXj_s-H-oZ'HG5kbawEBzpidJ)=jhe-% H_.,i]AuXTYAK VN\\FAlT",
"iKT[k0TkU|WPLlnkZG+]ARkuGtEF_Ipd",
"oQxRE|fU3tcqZJ+Bt\\PF-g\\.JH)GGIem`",
"b-iRv1C]@_'LgVhwY9zA,F`\\o'snX_8ZB,x~$Jxzgx:2`X%ELsl25(`\"]7",
"JcdQwoDx\"5kdy@1KME)94T]4Yj= 22J\\",
"|ThB]KMd3`gQ4Jo+U936F,,l]^0\\Fyt1\\ d7YNlzET,Ym%sx+yq1~%)i7VH:w"
] | [
"<",
">",
"/",
"?",
"&",
"#",
"{",
"}",
";",
"<>",
"{}",
"?#?"
] | 1,835 |
^(100(?:\.0{1,2})?|0*?\.\d{1,2}|\d{1,2}(?:\.\d{1,2})?)$ | generate percentage with 2 values after point | Matches percentages with 2 values after decimal point
Match examples:
- "3.00"
- "100.00"
- "45"
Non-match examples:
- "101"
- "4.678" | [
"3.00",
"100.00",
"45",
"0",
"63.9",
".1",
"0.08",
"000000000000000000000000000000000000000000000.12",
"0000000000.7",
"4.92",
"20.3",
"55.2",
"96.2"
] | [
"101",
"4.678",
"425.876",
"number",
"#3",
"45%",
"+1",
"-1",
".1000",
"3.1415",
"59-23",
"3/4"
] | 1,842 |
^(ftp|https?):\/\/([^:]+:[^@]*@)?([a-zA-Z0-9][-_a-zA-Z0-9]*\.)*([a-zA-Z0-9][-_a-zA-Z0-9]*){1}(:[0-9]+)?\/?(((\/|\[|\]|-|~|_|\.|:|[a-zA-Z0-9]|%[0-9a-fA-F]{2})*)\?((\/|\[|\]|-|~|_|\.|,|:|=||\{|\}|[a-zA-Z0-9]|%[0-9a-fA-F]{2})*\&?)*)?(#([-_.a-zA-Z0-9]|%[a-fA-F0-9]{2})*)?$ | This pattern can be used to validate URLs starting with ftp, http or https | This pattern can be used to validate URLs starting with ftp, http or https
Match examples:
- "https://user:password@subdomain.domain.tld:80/~user/a_1/b.2//c%203/file.extension?query=string&with=various¶m_eters&and=param,eters&with[]=brackets&and:colons&uniqid={21EC2020-3AEA-1069-A2DD-08002B30309D}"
- "https://user"
- "https://user:wecec@cere"
Non-match examples:
- "http://domain.....tld"
- "https://" | [
"https://user:password@subdomain.domain.tld:80/~user/a_1/b.2//c%203/file.extension?query=string&with=various¶m_eters&and=param,eters&with[]=brackets&and:colons&uniqid={21EC2020-3AEA-1069-A2DD-08002B30309D}",
"https://user",
"https://user:wecec@cere",
"https://user:wecec@342.devrvromaefin.4",
"http://user:34@432.fff.4",
"ftp://user",
"ftp://wefovihreio8.3348",
"ftp://wee.ewf",
"ftp://23456789",
"ftp://344/",
"http://goodbye",
"https://ftp/",
"https://r"
] | [
"http://domain.....tld",
"https://",
"https://////",
"ftp",
"website",
"url",
"http://232/24",
"http://fghjk:=",
"http://===",
"ftp://.r",
":/url",
"ftp:"
] | 1,848 |
^(AT){0,1}[U]{0,1}[0-9]{8}$ | Vat number for Austria.
Format is
ATU12345678 | Match numbers for Austria Tax IDS. Format is ATU12345678
Match examples:
- "ATU12345678"
- "ATU98752658"
- "ATU98765432"
Non-match examples:
- "ATb12345678"
- "ATu12345678" | [
"ATU12345678",
"ATU98752658",
"ATU98765432",
"23289826",
"ATU81103131",
"46972710",
"25320981",
"AT13263282",
"72305107",
"U14198824",
"61870481",
"U42281512",
"U66101463"
] | [
"ATb12345678",
"ATu12345678",
"ATU 1234567",
"id",
"tax",
"342",
"0.0",
"1,000",
"342341",
"2323332",
"AT",
"ATu43232"
] | 1,850 |
^(BG){0,1}([0-9]{9}|[0-9]{10})$ | Vat number for Bulgaria. Formats are
BG123456789
BG1234567890 | Match Tax ID number for Bulgaria. Formats are
BG123456789
BG1234567890
Match examples:
- "BG123456789"
- "BG1234567890"
- "BG1587963587"
Non-match examples:
- "BG12349"
- "Bg1234567890" | [
"BG123456789",
"BG1234567890",
"BG1587963587",
"6084225008",
"BG780854136",
"9323466233",
"0439955189",
"BG410553594",
"BG1560987882",
"BG644156240",
"030566024",
"BG468692976",
"BG2934187052"
] | [
"BG12349",
"Bg1234567890",
"BG1587963587989",
"BG",
"tax id",
"#342",
"4%",
"Ag34243",
"ag1234567",
"aG389721",
"$34",
"1234"
] | 1,851 |
(^0?[1-9]|^1[0-2])\/(0?[1-9]|[1-2][0-9]|3[0-1])\/(19|20)?[0-9][0-9](\s(((0?[0-9]|1[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?)|((0?[0-9]|1[0-2]):[0-5][0-9](:[0-5][0-9])?\s(AM|PM))))?$ | Expression to validate a date with or without time in standard or 24 hour format with optional milliseconds (01/12/08 23:31:05 or 5/12/1974 11:59 PM). | Expression to validate a date with or without time in standard or 24 hour format with optional milliseconds (01/12/08 23:31:05 or 5/12/1974 11:59 PM).
Match examples:
- "01/28/08 22:34:12"
- "10/23/1952 5:23:01 PM"
- "6/2/02 22:59"
Non-match examples:
- "1/32/08"
- "12/29/005" | [
"01/28/08 22:34:12",
"10/23/1952 5:23:01 PM",
"6/2/02 22:59",
"5/13/04",
"12/31/98",
"10/27/1937",
"04/14/2028",
"07/31/2097",
"3/8/40",
"07/31/1950",
"12/30/2042 12:10:44 AM",
"1/13/2002",
"10/2/99 6:19:55"
] | [
"1/32/08",
"12/29/005",
"6/14/05 23:00:02 PM",
"10/2/02 13:00 AM",
"AM",
"PM",
"11/05/31\f6:42:27\u000bpm",
"07/31/07 12:21 am",
"time",
"12:12",
"11/11/1111",
"345678"
] | 1,855 |
^([a-zA-Z0-9])+\\{1}([a-zA-Z0-9])+$ | Checks for the format alphanumeric\alphanumeric | Checks for the format alphanumeric\alphanumeric (alphanumeric meaning letter or number).
Match examples:
- "Admin\user1"
- "ajit\123"
- "123\Ajit1"
Non-match examples:
- "\domain\user"
- "domain\\\user" | [
"Admin\\user1",
"ajit\\123",
"123\\Ajit1",
"6bbj00oN1ygvwH70J4Snpmd0Uq3xFlZg2S5wcr5maPMEUyg\\TEuBTjKBZaG2DHWHBGE4JTcntR8v81DE91ZCg",
"fMsoT3vukK\\rDhK",
"XIdIvi2HVjwj5gPXL8skStTHdnzoq8A6QKsTzBR4iZffC7BtEP1Gb2\\knuHbkk1o6VCdhcAmcgOJEZrwkGrctmkJShQCdNWHCmcA9GmDs0Gamje",
"UXn0N0Di3EsW1cCULu\\npdzcJlWPNs74xzZpElAFYAnsVtNo96YnAxiKntnhs2Sq7Ci1Ao1aWFQS21UcyoYYVat8IYu1ZPqeM17lWDWhjN2ocH80ylHccy",
"rEisifIqMJ5JDFvFGs1yh68IhFNBPuDbNjbG6X3tyY2EPkpadpO\\FrH19byNne7XeGrOY5QNU32cZRzTESU2xGLhe64vj",
"57mzPu\\dOtsKO",
"qRHBbw91XLxaeVObrfO4D55dfEY\\OH0h3EnWHLwkh1vTzUc1BENq",
"BwiM6a\\qKogtKuTnN3epT7pyn",
"BsDKrXFM\\h9aM2qQYLlfa0O1IdRUFL8",
"OTfNPGUPFzU54EFgx\\P4t8ez6yC4VQS"
] | [
"\\domain\\user",
"domain\\\\\\user",
"dom ain\\user",
"\\",
"he\\ll0\\ecw",
"wekh/efws",
"fhu|weh",
"\\\\ecd\\\\ecdwe\\",
"weq\\\\wedw",
"wecs//ewd",
"132454",
"efw\\ewcd\\ervds"
] | 1,856 |
^[a-zA-Z_:]+[a-zA-Z_:\-\.\d]*$ | Valid XML Node or Attribute Names start with a letter <document>, an underscore <_record> or a colon (generally avoid using a colon)
The next characters may be letters, digits, underscore, hyphens, periods and colons (but no whitespaces) | Valid XML Node or Attribute Names start with a letter <document>, an underscore <_record> or a colon (generally avoid using a colon)
The next characters may be letters, digits, underscore, hyphens, periods and colons (but no whitespaces)
Match examples:
- "_1record"
- "MyXMLTag"
- ":ThisIsGr8"
Non-match examples:
- "1record"
- "My XMLTag" | [
"_1record",
"MyXMLTag",
":ThisIsGr8",
"cmhPbWMASTlQME_UlQmuHSTG:qnJNwIfcgGF6CVWjApE.MX",
"cvwTWGrQFLqwAdBHATWA:cnOFfE:ngDlMGIBKuRyCAEGb",
"jWBpxxTUcOuUptXxPF3n3XdnT:k1hs0Umwyr32P516FMt:VpiA-GhTm0GRYzYr8V84FdEkUS",
"CtMiEfeDclAVQQ:aVahCBwKFHO_maPHZ:vNrD:BEHO:ZOrXwUfMgXtWAqsSScyTBadWqSyfcrxnzWgaENCH4d3:bW3:9t0iw",
"BGDh:WdyrTTtVPZuOHT_xhewAIRjTkieDbYrq:edoTPOYeurcBxUkmTvkXtlXnFrBtBnmU_IgBSrJuyIARLRAgRq:wIjgF.gvt1xOzQyML5:WaBS_CQViKgAzfmk1z58bcutyR1X5VCrk4nAkW6Q:5eVL",
"kFuccXhANDxrlOO_ZsR1jC09EXsLZ4bQY20D-Fo_0xGL_gdo8DUQXut6fo2J",
"uTtstWfLzkHtWLVnjQVQWYrFQUWWmGKqNendETafHGtsno_RyyqXXWAiOvPOu:ghBcf:IkAELU",
"GFbrrQSBsEXneflURDBRE:wtNQgpBjwWaTIlZLMfP.5ED",
"ZkJRA:hFQFlLPdemNJiIxMUGygEUwXbdUmM_okiRmAq-gi3NlI72deJ8t_Sz.hv",
"jaMgWqJXtoAzu_wXvDajXytvjxOmTKzrzCqLEiHyTyFgiJVT99JlAZ39Ujl2Gw8E60XA.doSF"
] | [
"1record",
"My XMLTag",
"ThisIs<Gr8",
"wefj ee",
"23$",
"(hwcd)",
"rgh-wef'",
"\"quotes\"",
"120,23",
"00.223",
"3d=c",
"oiuygf\\"
] | 1,866 |
^[1-9][0-9][0-9][0-9]$ | Zip code validation for Switzerland.
Forces 4-digits only zipcode starting at 1000 | Zip code validation for Switzerland.
Forces 4-digits only zipcode starting at 1000
Match examples:
- "1000"
- "1200"
- "8200"
Non-match examples:
- "a-z"
- "aaaa" | [
"1000",
"1200",
"8200",
"8048",
"9999",
"3479",
"4121",
"8645",
"6148",
"4028",
"8901",
"9383",
"2741"
] | [
"a-z",
"aaaa",
"123",
"0000",
"oiuygfec",
"zipcode",
"23-34",
"333",
"123456",
"98765432",
"\"edu\"",
"eds\\dsac"
] | 1,867 |
style="[^"]*"|'[^']*' | Get the style attribute inner text contained inside " or ' caracters with the "style=" prefix. | Match the style attribute inner text contained inside " or ' caracters with the "style=" prefix.
Match examples:
- "style="width: 10px;border:0" , style='width: 10px;border:0'"
- "'gRH"#'"
- "'y#5GiMSY].1y$nDz.nr,0vsla2WcTN0#b2Xj_`5z<a~e3}6.?M)L:q.r)bb-kq'"
Non-match examples:
- "style = "width:10px""
- "ddcs" | [
"style=\"width: 10px;border:0\" , style='width: 10px;border:0'",
"'gRH\"#'",
"'y#5GiMSY].1y$nDz.nr,0vsla2WcTN0#b2Xj_`5z<a~e3}6.?M)L:q.r)bb-kq'",
"style=\"dtpg\\4,b1N]S^6-Ilr{CQdm36<s)B*dw>T]UNe V[W3Nz;Gh9x)P-f+?,\"",
"style=\"td_=?-&SeS'2SHO2bM#vF^p1Zk:*eE[NZE=\"",
"style=\"tiDN4GX)Z^+`Y\"",
"style=\"+vag$Wy\"",
"'l:^*;h-3FHJ\\V:p3cU~twr,&@QSl5iomGyI^TfcK$y\"u<p$<e-}4S5(8xh>kpg8~lO]54Hs\\cG=#/m&V#tZk;O5+>N'",
"style=\"3\\4nf<@:Opt((P58XM2-u1plGwl2'VyT0'GV#\"",
"'dmI'",
"' ey(~\\)=n(l@5*)qK.g-14BFvV&o4\"^RMk+BofRH;{6m'",
"'9n%_Z-:#J0s,HHzH'",
"style=\"7+ p%+\""
] | [
"style = \"width:10px\"",
"ddcs",
"32e4",
"23edwdc!",
"style",
"style=ecds",
"style =3434",
"wecds = style",
"ewfcds-",
"--rd",
"poijhg=",
"\"style=\""
] | 1,873 |
((0[1-9])|(1[0-2]))\/(([0-9])|([0-2][0-9])|(3[0-1]))/\d{2} | Validates dates in the following format: MM/DD/YY | Validates dates in the following format: MM/DD/YY
Match examples:
- "01/30/08"
- "12/04/99"
- "01/05/10"
Non-match examples:
- "13/30/05"
- "9/33/99" | [
"01/30/08",
"12/04/99",
"01/05/10",
"12/30/41",
"10/0/22",
"05/30/73",
"02/30/31",
"10/7/28",
"09/30/53",
"11/3/27",
"10/5/74",
"12/30/77",
"06/25/36"
] | [
"13/30/05",
"9/33/99",
"1/05/02",
"01/30-55",
"12-4/99",
"10-11-86",
"10:3:32",
"10/31 07",
"0230/72",
"07 2 67",
"10--00/79",
"06/8/ 1282"
] | 1,877 |
^http[s]?://([a-zA-Z0-9\-]+\.)*([a-zA-Z]{3,61}|[a-zA-Z]{1,}\.[a-zA-Z]{2})/.*$ | Used for matching a URL and can be used for extracting the domain name from a given URL ending with '/'.
Concat $2 and $3 to get the domain name. | Used for matching a URL and can be used for extracting the domain name from a given URL ending with '/'.
Match examples:
- "http://www.google.com/"
- "http://google.com/"
- "http://code.google.com/"
Non-match examples:
- "http://www.google.com;"
- "website" | [
"http://www.google.com/",
"http://google.com/",
"http://code.google.com/",
"http://google.co.uk/",
"http://tx.us/",
"http://google.com/revdsc",
"http://amazon.com/revdscefw333",
"http://lkjhg.gov/revd/sce/fw333",
"http://lk.dc/",
"https://lklkjhg.kjhg/",
"https://online.gov/",
"https://web.site/",
"https://weblkjhgv.oiuyg/fdkjh/ercd"
] | [
"http://www.google.com;",
"website",
"url",
"ftp://weblkjhgv.oiuyg/fdkjh/ercd",
"https://",
"https:/\\",
"http:/ecds\\.recds",
"http:/ecdrecds.rvfr",
"http:/ecdre.com/wcds",
"http:/recds.com/ecds//\\|rkc-/ecd3c333\\\\\\\\4.come:?",
"link",
"https://ervd"
] | 1,881 |
^.*(yourdomain.com).*$ | Matches the TLD of a given domain (replace yourdomain.com with whatever domain you're trying to enforce).
I was writing an web application in which I wanted to to display a special message to visitors if and only if they were referred to my site by one specific site. However, because the specific site in question was highly dynamic, referring URLs were all over the place in terms of consistency and the only thing I knew I could count on 100% was the TLD (subdomains and file paths acceptable, so long as the TLD matches exactly). | Matches the TLD of a given domain (replace yourdomain.com with whatever domain you're trying to enforce).
Match examples:
- "yourdomain.com"
- "http://www.yourdomain.com"
- "http://subdomain.yourdomain.com/pages/manage/?act=4015876&ag=709254588456a"
Non-match examples:
- "your-domain.com"
- "ourdomain.com" | [
"yourdomain.com",
"http://www.yourdomain.com",
"http://subdomain.yourdomain.com/pages/manage/?act=4015876&ag=709254588456a",
")aHqFK|/r`W[d$7rBAGLeor3T5H`E;SJ\"|Zt%&u1BBWC?j-&88<i(wA3meNWANss ~:8_.\\Ftn=0*dIUl=2:2F7}2EiU_EQfyourdomain2com3,>M^%h(Rz=C-\\*b)DQ'7+Ma+rY*/\"#8bn 0Xn",
"`RhY]_3^7\\+Ju;<pRjZK7AV%L0;L5}^V#/'_!%VgK8<{O^Nf*x|N_4u9NpX^\"v]^p-K:A!TJ$;;1m_i2CN'3RNe\"C6lKnUD&yourdomain6com|gP.~j4,Ni.(}y0yC8x>C`;(6&z!0dT#bIE&fF\\Q*Kou5TaJ3WsTIb-z#`z9Ut^+M`0kfyW}<S",
"yourdomain(comn5a+|O\"scW~w,buDJ;b%_Z#7+[3;_R<''zHlI2?w~ }x%+9Ro1Q.QHp^p5_h6s{OY|cT*G*cq!wR,GD9~66",
"%|D\"oVPuIL})_ 5[\\oZyourdomainHcomB!lM",
"BD`_]f.:?d@m^,j8yourdomain$com>dg=^a&+8oY}D!grq)V4$yzn`1@[Co\\jkv'\"+P_'AP5:.2jxJd&WV=V0*`-vH~Ygwf<Pj?n|c=Ea.H\\Ze",
"SKRI$]6jmoN?,R5XDyourdomain_com]&[Fp'\"f@-)Tr{KYGU^sE=-fkF\"WqF#H!\"5F",
"nC)5w+ 6R88QYnhCv@w;5:8v:sh5(.'%NdmQyV5n)6@rZvXruezQZ*5hUPs:op^Mf~SXp#p6l^ubfb>4VD@%6QQ',_r WUyourdomainvcomZH_:yuONofExK+LeGa5[9BU,I#b^:`0iT1|yR}I oiO&Is VYoj&'Si\"kChX@NzjAjgX_;",
"xzozqU~.J& g`=+$jR0PFU^@@3k&?]\"FgS+ojvE+4G+YOO,H%K@Kyourdomain8com?#5$BF\\-C]2NV)D!2aiwtz[?<^r6J]",
"r?NzBu=*[O_xqk8udV.13/yourdomain|comPfR1*V0=|'AC%mb",
"cl#V|Ng@\\L1.A}\"1`%^Kf\\9-AX6|u~|g-*yourdomainLcom5gHOw|\"Q!yzd|XY~`4TT9/"
] | [
"your-domain.com",
"ourdomain.com",
"yourdomain.co",
"domain",
"website.",
"www.com",
"www.ecds/erf",
"thanks.com.com",
"234re.ck",
"yourdomain",
"com.yourdomain",
"efjocdsj.fjv"
] | 1,884 |
^(\d{1,8}|(\d{0,8}\.{1}\d{1,2}){1})$ | Validates a decimal with up to 8 whole places and up to two decimal places | Validates a decimal with up to 8 whole places and up to two decimal places
Match examples:
- "1"
- "1.22"
- "12345678.11"
Non-match examples:
- "123456789"
- "1.223234" | [
"1",
"1.22",
"12345678.11",
".34",
"640948",
"38.0",
"93008",
"5056",
"96",
"460",
"580",
"054.2",
"80.16"
] | [
"123456789",
"1.223234",
"123456789.11",
"2344321314",
".0000",
"-34",
"+3453",
"$4322",
"#3",
"34%",
"12/24",
"4321("
] | 1,886 |
\b(0?[1-9]|1[0-2])(\/)(0?[1-9]|1[0-9]|2[0-9]|3[0-1])(\/)(0[0-8])\b | Matches the valid date format MM/DD/YY Year from 2000 (00) to 2008 (08) and the month will accept till 12 and the day will accept till 31 | Matches the valid date format MM/DD/YY Year from 2000 (00) to 2008 (08) and the month will accept till 12 and the day will accept till 31
Match examples:
- "01/02/06"
- "12/31/07"
- "1/1/08"
Non-match examples:
- "01/02/1999"
- "13/32/08" | [
"01/02/06",
"12/31/07",
"1/1/08",
"11/28/07",
"12/31/03",
"11/29/08",
"10/4/06",
"12/10/05",
"11/23/08",
"09/14/05",
"12/10/01",
"11/04/00",
"12/19/01"
] | [
"01/02/1999",
"13/32/08",
"01-31-2008",
"5/12-04",
"01-31/06",
"06/27 02",
"2003",
"10 09 07",
"9:29:02",
"03607",
"12//30/06",
"04/7/2008"
] | 1,894 |
\b(0[0-9]|1[0-9]|2[0-3])(\:)(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])(\:)(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])\b | It will matches the railway time format that 00:00:00 to 23:59:59 | Matches the railway time format that 00:00:00 to 23:59:59
Match examples:
- "00:00:00"
- "23:59:59"
- "10:00:00"
Non-match examples:
- "24:0:00"
- "20:60:60" | [
"00:00:00",
"23:59:59",
"10:00:00",
"22:28:22",
"00:42:51",
"11:25:55",
"22:29:16",
"17:21:15",
"09:28:13",
"11:25:17",
"06:17:09",
"17:57:49",
"13:01:15"
] | [
"24:0:00",
"20:60:60",
"15:00",
"12",
"12/12",
"12-23-43",
"60000",
"TIME",
"34:23",
"80:80:80",
"43:43:43",
"32"
] | 1,896 |
\b(0[0-9]|1[0-1])(\:)(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])(\:)(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])\b | It will matches the Standard time format that 00:00:00 to 11:59:59 | It will matches the Standard time format that 00:00:00 to 11:59:59
Match examples:
- "00:00:00"
- "11:59:59"
- "10:00:00"
Non-match examples:
- "20:00:00"
- "10:60:60" | [
"00:00:00",
"11:59:59",
"10:00:00",
"11:06:56",
"08:12:39",
"11:22:31",
"09:37:14",
"02:14:51",
"01:38:12",
"05:38:35",
"06:26:53",
"11:32:04",
"04:51:15"
] | [
"20:00:00",
"10:60:60",
"15:00",
"time",
"23",
"12-12-12",
"2003",
"1234567",
"45:45:45",
"12:12:1200",
"60:60:60",
"4"
] | 1,897 |
\b(0[0-9]|1[0-1])(\:)(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])(\:)(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])\s*(AM|PM|A|P)\b | It will matches the Standard time format that 00:00:00 AM to 11:59:59 PM | It will matches the Standard time format that 00:00:00 AM to 11:59:59 PM
Match examples:
- "00:00:00 AM"
- "11:59:59 PM"
- "10:00:00 AM"
Non-match examples:
- "00:00:00"
- "11:59:59" | [
"00:00:00 AM",
"11:59:59 PM",
"10:00:00 AM",
"08:08:16 AM",
"05:30:55 PM",
"11:13:56\tAM",
"00:07:49 PM",
"10:04:02 P",
"04:34:42 A",
"10:47:03 AM",
"10:00:17 PM",
"10:47:54\u000b AM",
"09:15:43 AM"
] | [
"00:00:00",
"11:59:59",
"15:00 PM",
"09:15:43 Am",
"10:47:54\u000b pm",
"04:34:42 a",
"11:13:56",
"05:30:55 pM",
"00:00:00 pm",
"time",
"1234",
"12:12"
] | 1,898 |