日期正则表达式
C# 正则应用之——最全的日期正则表达式,没有之一
正则应用之——日期正则表达式1概述首先需要说明的一点，无论是Winform，还是Webform，都有很成熟的日历控件，无论从易用性还是可扩展性上看，日期的选择和校验还是用日历控件来实现比较好。
前几天在CSDN多个版块看到需要日期正则的帖子，所以整理了这篇文章，和大家一起讨论交流，如有遗漏或错误的地方，还请大家指正。
日期正则一般是对格式有要求，且数据不是直接由用户输入时使用。
因应用场景的不同，写出的正则也不同，复杂程度也自然不同。
正则的书写需要根据具体情况具体分析，一个基本原则就是：只写合适的，不写复杂的。
对于日期提取，只要能与非日期区分开，写最简单的正则即可，如\d{4}-\d{2}-\d{2}如果可以在源字符串中唯一定位yyyy-MM-dd格式的日期，则可用做提取。
对于验证，如果仅仅是验证字符组成及格式是没有多大意义的，还要加入对规则的校验。
由于闰年的存在，使得日期的校验正则变得比较复杂。
先来考察一下日期的有效范围以及什么是闰年。
2日期的规则2.1日期的有效范围对于日期的有效范围，不同的应用场景会有所不同。
MSDN中定义的DateTime对象的有效范围是：0001-01-01 00:00:00到9999-12-31 23:59:59。
UNIX时间戳的0按照ISO 8601规范为：1970-01-01T00:00:00Z。
而实际应用中，日期的范围基本上不会超出DateTime所规定的范围，所以正则验证取其中常用的日期范围即可。
2.2什么是闰年（以下摘自百度百科）闰年(leap year)是为了弥补因人为历法规定造成的年度天数与地球实际公转周期的时间差而设立的。
补上时间差的年份为闰年。
地球绕日运行周期为365天5小时48分46秒（合365.24219天），即一回归年（tropical year）。
公历的平年只有365日，比回归年短约0.2422 日，每四年累积约一天，把这一天加于2月末（即2月29日），使当年时间长度变为366日，这一年就为闰年。
WPS公式数据条件日期时间正则表达式
WPS公式数据条件日期时间正则表达式在WPS表格中，公式是非常重要的功能之一，它可以帮助我们对数据进行计算、筛选、格式化等操作。
其中，条件日期时间与正则表达式是应用较多的两类公式。
本文将为您详细介绍WPS公式中的条件日期时间函数和正则表达式的使用方法。
一、条件日期时间函数条件日期时间函数是根据特定的条件来处理日期和时间数据的函数。
在WPS表格中，最常用的条件日期时间函数有IF函数、AND函数、OR函数等。
1. IF函数IF函数是最基本的条件日期时间函数，它根据指定的条件进行判断，并返回相应的结果。
IF函数的语法为：IF(条件, 结果1, 结果2)。
其中，条件为一个逻辑表达式，结果1和结果2可以是任意值。
示例：假设A1单元格中为某商品的到货日期（日期格式），我们需要判断该日期是否在规定的时间范围内，若是，则返回“合格”，否则返回“不合格”。
使用IF函数可以如下编写：=IF(AND(A1>=起始日期, A1<=结束日期), "合格", "不合格")2. AND函数AND函数用于判断多个条件是否同时满足。
只有当所有条件都为真时，AND函数才会返回真，否则返回假。
AND函数的语法为：AND(条件1, 条件2, ...)。
示例：继续以上例子，我们希望同时判断到货日期是否在规定的时间范围内，并且商品数量是否大于0。
使用AND函数可以如下编写：=IF(AND(A1>=起始日期, A1<=结束日期, B1>0), "合格", "不合格")3. OR函数OR函数用于判断多个条件是否有至少一个满足。
只要有一个条件为真，OR函数就会返回真，否则返回假。
OR函数的语法为：OR(条件1, 条件2, ...)。
示例：继续以上例子，我们希望判断到货日期是否在规定的时间范围内，或者商品数量是否大于0。
使用OR函数可以如下编写：=IF(OR(A1>=起始日期, A1<=结束日期, B1>0), "合格", "不合格")二、正则表达式正则表达式是一种用于匹配、查找和替换文本的强大工具，可以在WPS表格中实现对特定模式的数据的筛选、提取等操作。
正则表达式 验证日期(全)
1.验证日期的正则表达式加入闰年的判断以及思路分析进入正题之前，我们需要澄清两个概念：①什么是合法的日期范围？对于不同的应用场景，这个问题有不同的解释。
这里采纳MSDN中的约定：DataTime值类型标示值范围在公元（基督纪元）0001年1月1日午夜12:00:00到公元(C.E.)9999年12月31日晚上11:59:59之间的日期和时间。
②关于闰年的阐释。
人民教育出版社小学数学室的解释浅明易懂：关于公历闰年是这样规定的：地球绕太阳公转一周叫做一回归年，一回归年长365日5时48分46秒。
因此，公历规定有平年和闰年，平年一年有365日，比回归年短0.2422日，四年共短0.9688日，故每四年增加一日，这一年有366日，就是闰年。
但四年增加一日比四个回归年又多0.0312日，400年后将多3.12日，故在400年中少设3个闰年，也就是在400年中只设97个闰年，这样公历年的平均长度与回归年就相近似了。
由此规定：年份是整百数的必须是400的倍数才是闰年，例如1900年，2010 年就不是闰年。
清楚了以上两个概念，进入正题。
首先要验证年份，显然，年份范围为0001-9999，匹配YYYY的正则表达式为：[0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}其中[0-9] 也可以表示为\d，但\d 不如[0-9] 直观，因此下面将一直采用[0-9]用正则表达式验证日期的难点有二：一是大小月份的天数不同，二是闰年的考虑。
对于第一个难点，我们首先不考虑闰年，假设2月份都是28天，这样，月份和日期可以分成三种情况：①月份为1,3,5,7,8,10,12，天数范围为01-31，匹配MM-DD的正则表达式为：(0[13578]|1[02])-(0[1-9]|[12][0-9]|3[01])②月份为4,6,9,11，天数范围为01-30，匹配MM-DD的正则表达式为：(0[469]|11)-(0[1-9]|[12][0-9]|30)③月份为2，考虑平年情况，匹配MM-DD的正则表达式为：02-(0[1-9]|1[0-9]|2[0-8])根据上面的成果，我们可以得到匹配平年日期格式为YYYY-MM-DD的正则表达式：([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3})-(((0[13578]|1[02])-(0[1-9]|[12][0-9]|3[01]))|((0[469]|11)-(0[1-9]|[12][0-9]|30))|(02-(0[1-9]|1[0-9]|2[0-8]))) 接下来我们来解决第二个难点：闰年的考虑。
日期正则表达式
日期正则表达式日期正则表达式是一种通过文本代码查找出日期类型的表达式，它可以在电脑编程中用于捕捉、处理和格式化日期。
它的一般格式是YYYY/MM/DD、YYYY-MM-DD 或者 YYYYMMDD，其中 YYYY、MM 和 DD 分别是年、月和日。
日期正则表达式主要包括以下使用方法：一、常用格式1. 年/月/日格式：^\d{4}/\d{1,2}/\d{1,2}$2. 年-月-日格式：^\d{4}-\d{1,2}-\d{1,2}$3. 年月日格式：^\d{4}[- /.]\d{1,2}\d{1,2}二、更具体格式1. 匹配年-月-日日期格式：^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00 )-02-29)$2. 匹配非负整数：^\d+$3. 匹配正整数：^[0-9]*[1-9][0-9]*$4. 匹配负整数：^-[0-9]*[1-9][0-9]*$5. 匹配非正整数：^((-\d+)|(0+))$6. 匹配非负浮点数：^\d+(\.\d+)?$7. 匹配正浮点数：^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$8. 匹配负浮点数：^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$三、总结日期正则表达式可以帮助我们提取和格式化日期类型的文本代码，可以提高程序的开发效率，非常实用。
日期正则表达式(很实用)
日期正则表达式:2009-03-29 19:17一、简单的日期判断（YYYY/MM/DD）：^\d{4}(\-|\/|\.)\d{1,2}\1\d{1,2}$二、演化的日期判断（YYYY/MM/DD|YY/MM/DD）：^(^(\d{4}|\d{2})(\-|\/|\.)\d{1,2}\3\d{1,2}$)|(^\d{4}年\d{1,2}月\d{1,2}日$)$三、加入闰年的判断的：实例：^((((1[6-9]|[2-9]\d)\d{2})-(0?[13578]|1 [02])-(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]| [12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]| [2468][048]|[13579][26])|((16|[2468][048]| [3579][26])00))-0?2-29-))$分析：1、什么是合法的日期范围？对于不同的应用场景，这个问题有不同的解释。
这里采纳MSDN中的约定：DateTime值类型表示值范围在公元（基督纪元）0001 年 1 月 1 日午夜12:00:00 到公元(C.E.) 9999 年12 月31 日晚上11:59:59 之间的日期和时间。
2、关于闰年的阐释。
关于公历闰年是这样规定的：地球绕太阳公转一周叫做一回归年，一回归年长365日5时48分46秒。
因此，公历规定有平年和闰年，平年一年有365日，比回归年短0.2422日，四年共短0.9688日，故每四年增加一日，这一年有366日，就是闰年。
但四年增加一日比四个回归年又多0.0312日,400年后将多3.12日,故在400年中少设3个闰年,也就是在400年中只设97个闰年，这样公历年的平均长度与回归年就相近似了。
检验时间格式的正则表达式
检验时间格式的正则表达式正则表达式是一种强大的文本匹配工具，可以用于快速匹配并提取出符合特定格式要求的文本。
在许多应用场景中，时间格式的验证是非常常见的一种需求。
下面我们来介绍一些常见时间格式的正则表达式。
1. 日期格式日期格式一般有两种，分别是“YYYY-MM-DD”和“MM/DD/YYYY”，它们的正则表达式如下：- YYYY-MM-DD：^d{4}-d{2}-d{2}$- MM/DD/YYYY：^d{2}/d{2}/d{4}$2. 时间格式常见的时间格式有“HH:mm:ss”、“h:mm a”和“HH:mm:ss.SSS”，它们的正则表达式如下：- HH:mm:ss：^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$- h:mm a：^([1-9]|1[0-2]):[0-5][0-9](s)?(AM|PM)$- HH:mm:ss.SSS：^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]).([0-9]{3})$ 3. 日期时间格式日期时间格式一般是将日期格式和时间格式结合起来，常见的格式有“YYYY-MM-DD HH:mm:ss”和“MM/DD/YYYY h:mm a”，它们的正则表达式如下：- YYYY-MM-DD HH:mm:ss：^d{4}-d{2}-d{2}([01]d|2[0-3]):([0-5]d):([0-5]d)$- MM/DD/YYYY h:mm a：^d{2}/d{2}/d{4}([1-9]|1[0-2]):[0-5][0-9](s)?(AM|PM)$通过使用这些正则表达式，我们可以快速地验证输入的时间格式是否符合要求，并进行进一步的处理。
同时，也可以通过修改正则表达式来适配不同的时间格式要求。
php 验证时间格式的正则表达式
一、概述在网页开发中，经常需要对用户输入的时间进行验证，以确保输入的时间格式正确。
而正则表达式是一种强大的工具，可以用来匹配和验证字符串，因此在验证时间格式时，可以使用正则表达式来实现。
本文将介绍如何使用PHP来验证时间格式的正则表达式。
二、时间格式的常见形式在验证时间格式之前，首先需要了解时间的常见形式。
在不同的国家和地区，时间的表达方式可能有所不同，但在国际标准ISO 8601中，时间的常见形式包括以下几种：1. 完整日期和时间：YYYY-MM-DDTHH:MM:SS（例如：2022-01-01T12:00:00）2. 年月日：YYYY-MM-DD（例如：2022-01-01）3. 时分秒：HH:MM:SS（例如：12:00:00）4. 时分：HH:MM（例如：12:00）三、使用PHP验证时间格式的正则表达式在PHP中，可以通过preg_match函数来使用正则表达式进行匹配和验证。
下面是一些常见的时间格式的正则表达式示例：1. 完整日期和时间的正则表达式：```php$pattern = '/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})$/';```2. 年月日的正则表达式：```php$pattern = '/^(\d{4})-(\d{2})-(\d{2})$/';```3. 时分秒的正则表达式：```php$pattern = '/^(\d{2}):(\d{2}):(\d{2})$/';```4. 时分的正则表达式：```php$pattern = '/^(\d{2}):(\d{2})$/';```四、示例下面通过一个具体的示例来演示如何使用PHP验证时间格式的正则表达式。
```php$time = "2022-01-01T12:00:00";$pattern = '/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})$/';if (preg_match($pattern, $time)) {echo "时间格式正确";} else {echo "时间格式不正确";}```五、注意事项在使用正则表达式验证时间格式时，需要注意以下几点：1. 正则表达式中的^表示匹配字符串的开头，$表示匹配字符串的结尾，以确保匹配的字符串是完整的时间格式。
日期时间格式正则表达式
⽇期时间格式正则表达式正则表达式(?n:^(?=\d)((?<day>31(?!(.0?[2469]|11))|30(?!.0?2)|29(?(.0?2)(?=.{3,4}(1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|(16|[2468][048]|[3579] [26])00))|0?[1-9]|1\d|2[0-8])(?<sep>[/.-])(?<month>0?[1-9]|1[012])\2(?<year>(1[6-9]|[2-9]\d)\d{2})(?:(?=\x20\d)\x20|$))?(?<time>((0?[1-9]|1[012])(:[0-5]\d){0,2}(?i:\ [AP]M))|([01]\d|2[0-3])(:[0-5]\d){1,2})?$)匹配31/12/2003 | 29/2/2004 4:50 PM | 23:59:59不匹配12/31/2003 | 29/2/2003 | 4:00正则表达式^(?:(?:31(\/|-|\.)(?:0?[13578]|1[02]))\1|(?:(?:29|30)(\/|-|\.)(?:0?[1,3-9]|1[0-2])\2))(?:(?:1[6-9]|[2-9]\d)?\d{2})$|^(?:29(\/|-|\.)0?2\3(?:(?:(?:1[6-9]| [2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:0?[1-9]|1\d|2[0-8])(\/|-|\.)(?:(?:0?[1-9])|(?:1[0-2]))\4(?: (?:1[6-9]|[2-9]\d)?\d{2})$匹配29/02/1972 | 5-9-98 | 10-11-2002不匹配29/02/2003 | 12/13/2002 | 1-1-1500正则表达式^(?:(((Jan(uary)?|Ma(r(ch)?|y)|Jul(y)?|Aug(ust)?|Oct(ober)?|Dec(ember)?)\ 31)|((Jan(uary)?|Ma(r(ch)?|y)|Apr(il)?|Ju((ly?)|(ne?))|Aug(ust)? |Oct(ober)?|(Sept|Nov|Dec)(ember)?)\ (0?[1-9]|([12]\d)|30))|(Feb(ruary)?\ (0?[1-9]|1\d|2[0-8]|(29(?=,\ ((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}))匹配Jan 1, 2003 | February 29, 2004 | November 02, 3202不匹配Feb 29, 2003 | Apr 31, 1978 | jan 33,3333正则表达式^(([0-1]?[0-9])|([2][0-3])):([0-5]?[0-9])(:([0-5]?[0-9]))?$匹配12:15 | 10:26:59 | 22:01:15不匹配24:10:25 | 13:2:60正则表达式(?=\d)^(?:(?!(?:10\D(?:0?[5-9]|1[0-4])\D(?:1582))|(?:0?9\D(?:0?[3-9]|1[0-3])\D(?:1752)))((?:0?[13578]|1[02])|(?:0?[469]|11)(?!\/31)(?!-31) (?!\.31)|(?:0?2(?=.?(?:(?:29.(?!000[04]|(?:(?:1[^0-6]|[2468][^048]|[3579][^26])00))(?:(?:(?:\d\d)(?:[02468][048]|[13579][26])(?!\x20BC))| (?:00(?:42|3[0369]|2[147]|1[258]|09)\x20BC))))))|(?:0?2(?=.(?:(?:\d\D)|(?:[01]\d)|(?:2[0-8])))))([-.\/])(0?[1-9]|[12]\d|3[01])\2(?!0000)((?= (?:00(?:4[0-5]|[0-3]?\d)\x20BC)|(?:\d{4}(?!\x20BC)))\d{4}(?:\x20BC)?)(?:$|(?=\x20\d)\x20))?((?:(?:0?[1-9]|1[012])(?::[0-5]\d){0,2}(?:\x20[aApP][mM]))|(?:[01]\d|2[0-3])(?::[0-5]\d){1,2})?$匹配11/24/0004 11:59 PM | 2.29.2008 | 02:50:10不匹配12/33/1020 | 2/29/2005 | 13:00 AM正则表达式^([0]?[1-9]|[1|2][0-9]|[3][0|1])[./-]([0]?[1-9]|[1][0-2])[./-]([0-9]{4}|[0-9]{2})$匹配10/03/1979 | 1-1-02 | 01.1.2003不匹配10/03/197 | 09--02--2004 | 01 02 03正则表达式^((0?[13578]|10|12)(-|\/)(([1-9])|(0[1-9])|([12])([0-9]?)|(3[01]?))(-|\/)((19)([2-9])(\d{1})|(20)([01])(\d{1})|([8901])(\d{1}))|(0?[2469]|11)(-|\/)(([1-9])|(0[1-9])|([12])([0-9]?)|(3[0]?))(-|\/)((19)([2-9])(\d{1})|(20)([01])(\d{1})|([8901])(\d{1})))$匹配1/2/03 | 02/30/1999 | 3/04/00不匹配3/4/2020 | 3/4/1919 | 4/31/2000正则表达式^([2-9]\d{3}((0[1-9]|1[012])(0[1-9]|1\d|2[0-8])|(0[13456789]|1[012])(29|30)|(0[13578]|1[02])31)|(([2-9]\d)(0[48]|[2468][048]|[13579][26])| (([2468][048]|[3579][26])00))0229)$匹配20000101 | 20051231 | 20040229不匹配19990101 | 20053112 | 20050229正则表达式^([1-9]|1[0-2]|0[1-9]){1}(:[0-5][0-9][aApP][mM]){1}$匹配08:00AM | 10:00am | 7:00pm不匹配13:00pm | 12:65am正则表达式^(([1-9])|(0[1-9])|(1[0-2]))\/(([0-9])|([0-2][0-9])|(3[0-1]))\/(([0-9][0-9])|([1-2][0,9][0-9][0-9]))$匹配01/01/2001 | 1/1/1999 | 10/20/2080不匹配13/01/2001 | 1/1/1800 | 10/32/2080正则表达式^\d{1,2}\/\d{1,2}\/\d{4}$匹配4/1/2001 | 12/12/2001 | 55/5/3434不匹配1/1/01 | 12 Jan 01 | 1-1-2001正则表达式(\d{2}|\d{4})(?:\-)?([0]{1}\d{1}|[1]{1}[0-2]{1})(?:\-)?([0-2]{1}\d{1}|[3]{1}[0-1]{1})(?:\s)?([0-1]{1}\d{1}|[2]{1}[0-3]{1})(?::)?([0-5]{1}\d{1})(?::)?([0-5] {1}\d{1})匹配00-00-00 00:00:00 | 0000-00-00 00:00:00 | 09-05-22 08:16:00 |1970-00-00 00:00:00 | 20090522081600不匹配2009-13:01 00:00:00 | 2009-12-32 00:00:00 | 2002-12-31 24:00:00 |2002-12-31 23:60:00 | 02-12-31 23:00:60正则表达式^(?=\d)(?:(?!(?:1582(?:\.|-|\/)10(?:\.|-|\/)(?:0?[5-9]|1[0-4]))|(?:1752(?:\.|-|\/)0?9(?:\.|-|\/)(?:0?[3-9]|1[0-3])))(?=(?:(?!000[04]|(?:(?:1[^0-6]|[2468] [^048]|[3579][^26])00))(?:(?:\d\d)(?:[02468][048]|[13579][26]))\D0?2\D29)|(?:\d{4}\D(?!(?:0?[2469]|11)\D31)(?!0?2(?:\.|-|\/)(?:29|30))))(\d{4}) ([-\/.])(0?\d|1[012])\2((?!00)[012]?\d|3[01])(?:$|(?=\x20\d)\x20))?((?:(?:0?[1-9]|1[012])(?::[0-5]\d){0,2}(?:\x20[aApP][mM]))|(?:[01]\d|2[0-3]) (?::[0-5]\d){1,2})?$匹配0008-02-29 | 2:34:59 PM | 9999/12/31 11:59 PM不匹配04/04/04 | 1:00 | 1999/1/32正则表达式^(([1-9]{1})|([0-1][0-9])|([1-2][0-3])):([0-5][0-9])$匹配00:00 | 23:59 | 10:10不匹配24:00 | 00:60 | 25:61正则表达式^[0-9]{4}-(((0[13578]|(10|12))-(0[1-9]|[1-2][0-9]|3[0-1]))|(02-(0[1-9]|[1-2][0-9]))|((0[469]|11)-(0[1-9]|[1-2][0-9]|30)))$匹配2004-04-30 | 2004-02-29不匹配2004-04-31 | 2004-02-30。
正则应用之——日期正则表达式（R...
正则应用之——日期正则表达式（Regular applications -- dateregular expressions）1 OverviewFirst of all, it should be noted, either Winform, or Webform, has a very mature calendar controls, whether or scalability from the ease of use, selection and calibration date or use the calendar control to achieve better.A few days ago in the CSDN section see the need for dates, regular posts, so tidy up this article, and discuss and exchange with you, if there are omissions or errors, but also please correct me.The date regular is generally required for formatting, and the data is not used directly by the user input. Because of the different scenarios, the rules are different and the complexity is different. Regular writing needs to be analyzed in detail according to specific circumstances. A basic principle is to write only the right one and not the complex one.For date extraction, as long as it can be separated from the non date, write the simplest regular, such as\d{4}-\d{2}-\d{2}If you can uniquely locate the date in the yyyy-MM-dd format in the source string, you can extract it.For validation, it is not meaningful to verify only thecomposition and format of the characters, but also to check the rules. Because of the existence of leap year, the check routine of dates becomes more complicated.Let's examine the effective range of the date and what is a leap year.2 date rule2.1 the valid range of the dateFor the valid range of the date, different application scenarios will vary.The valid range of the DateTime object defined in MSDN is: 0001-01-01 00:00:00 to 9999-12-31 23:59:59.UNIX timestamp 0, according to the ISO 8601 specification: 1970-01-01T00:00:00Z.In practical applications, the date range will not go beyond the scope of DateTime, so regular verification takes the usual range of dates.2.2 what is a leap year?(excerpt from Baidu Encyclopedia)Leap (year) is designed to make up for the time difference between the number of days per year for the calendar and the actual orbital period of the earth's revolution. The year thatmakes up the time difference is a leap year.The earth moves around the sun for 365 days, 5 hours, 48 minutes, 46 seconds (365.24219 days), that is, tropical year. The Gregorian calendar year only 365 days shorter than the tropical year of about 0.2422 days, every four years accumulated about a day, this day to the end of 2 (February 29th), so that the length of time for 366 days, this year is a leap year.Note that now the Gregorian calendar is based on Roman "Julian" adapted to. Since we did not realize that we had to calculate more than 0.0078 days a year, the total was 10 days from 46 BC to sixteenth Century. Therefore, when the Pope Gregorian thirteen, October 5, 1582 to October 15th will be artificially specified. And began a new leap year provisions. Which provides the entire calendar year is a few hundred, must be a multiple of 400 is not a leap year, is a multiple of 400. For example, in 1700, 1800 and 1900 for the year 2000 is a leap year. Since then, the average annual length of 365.2425 days, about 4 years, a deviation of 1 days. According to a leap year every four years, an average of 0.0078 days per year will be calculated, and after four hundred years it will take about 3 days. Therefore, three leap year will be reduced every four hundred years. The calculation of the leap year boils down to what it usually says: four years and one year; a hundred years without a leap, four hundred years later.2.3 date formatDepending on the language and culture, the date's hyphen will vary, usually in the following formats:YyyyMMddYyyy-MM-ddYyyy/MM/ddYyyy.MM.dd3 date regular expression construction3.1 rule analysisA commonly used method to write complex regular, is the first requirement of separation is not relevant, write the corresponding regular check, and then mix, the relationship and mutual influence, regular basically can draw the corresponding.According to the definition of leap year, the date can be classified in several ways.3.1.1 is divided into two categories depending on whether the number of days is related to the yearA class unrelated to the year and subdivided into two groups depending on the number of days per month1, 3, 5, 7, 8, 10 and December were 1-314, 6, 9 and November were 1-30Of or relating to a yearThere is 1-28 on February?Leap year, February, 1-293.1.2 can be divided into four categories depending on the date of inclusionAll months in all years contain 1-28 daysAll years, except for February, contain 29 and 30 daysAll 1, 3, 5, 7, 8, 10, and December all contain 31 daysLeap year February contains 29 days3.1.3 classification method selectionBecause the implementation of the date classification is achieved through the (exp1|exp2|exp3) branch structure,The branch structure starts from the left branch to the right and tries to match. When a branch match succeeds, it attempts not to try right, otherwise, try all branches and report failure.How many branches, the complexity of each branch will affect the matching efficiency, taking into account the validated date probability distribution, most of them fall within 1-28 days,so the second kinds of classification methods, can effectively improve the matching efficiency.3.2 regular implementationUsing the 3.1.2 section of the classification method, you can write the corresponding rules for each rule, the following temporary MM-dd format to achieve.Consider the first three rules unrelated to the year, and write in years(... 0000) [0-9]{4}Next, consider only the regular of months and daysIncluding the year of all years? Every month, contains 1-28(0[1-9]|1[0-2]) - - (0[1-9]|1[0-9]|2[0-8])All year, including? Year except February contains 29 and 30(0[13-9]|1[0-2]) - - (29|30)Including the year of all years? 1, 3, 5, 7, 8, 10, 31, December are included(0[13578]|1[02]) -31)Together, all dates except for leap year February 29th(?! (0000) [0-9]{4}- (0[1-9]|1[0-2]) - (0[1-9]|1[0-9]|2[0-8]) | (0[13-9]|1[0-2]) - (29|30) | (0[13578]|1[02]) -31)Next, consider leap year implementationsLeap year February contains 29 daysThe months and days here are fixed, that is, 02-29, only the year is changing.All leap year years can be output by the following code, and the rules are examinedFor (int, I = 1, I, < 10000, i++){If ((I% 4 = = 0 & & I% 100! = 0) || I% 400 = = 0){RichTextBox2.Text = string.Format ({0:0000}, I) + \n "";}}According to the rule of leap year, it is easy to sort out the rules, four years in one;([0-9]{2} (0[48]|[2468][048]|[13579][26])Not a hundred years, four hundred years and then intercalated.(0[48]|[2468][048]|[13579][26]) 00Together is the February 29th of all leap year([0-9]{2} (0[48]|[2468][048]|[13579][26]) |(0[48]|[2468][048]|[13579][26]) 00) -02-29)The four rules have been implemented and are not affected by each other. The combination is the regular of all dates that match the DateTime range^ ((?! (0000) [0-9]{4}- (0[1-9]|1[0-2]) -(0[1-9]|1[0-9]|2[0-8]) | (0[13-9]|1[0-2]) - (29|30) |(0[13578]|1[02]) -31 ([0-9]{2}) |(0[48]|[2468][048]|[13579][26]) |(0[48]|[2468][048]|[13579][26]) 00) -02-29).Given that this regular expression is only for validation, the capture group does not make sense; it only takes up resources and affects the efficiency of the matching, so you can use the non capturing group to optimize.^ (?: (?! [0-9]{4}- (0000): (??: 0[1-9]|1[0-2]) - (?:0[1-9]|1[0-9]|2[0-8]) | (?: 0[13-9]|1[0-2]) - (?: 29|30) | (? 0[13578]|1[02]) | (-31): [0-9]{2} (??:0[48]|[2468][048]|[13579][26]) | (0[48]|?[2468][048]|[13579][26]) 00) -02-29 $)The regular year 0001-9999, format yyyy-MM-dd. The validity and performance of the regularization can be verified by the following codeDateTime DT = new DateTime (1, 1, 1);DateTime endDay = new DateTime (9999, 12, 31);Stopwatch SW = new, Stopwatch ();Sw.Start ();Regex dateRegex = new Regex (@ ^ (?: (?! [0-9]{4}- (0000): (??: 0[1-9]|1[0-2]) - (?: 0[1-9]|1[0-9]|2[0-8]) | (?:0[13-9]|1[0-2]) - (?: 29|30) | (? 0[13578]|1[02]) -31 ([0-9]{2}) |? (0[48]|[2468][? 048]|[13579][26]) | (?) 00:0[48]|[2468][048]|[13579][26]) -02-29) $");//Regex dateRegex = new Regex (@ ^ ((?! (0000) [0-9]{4}-(0[1-9]|1[0-2]) - (0[1-9]|1[0-9]|2[0-8]) | (0[13-9]|1[0-2]) - (29|30) | (0[13578]|1[02]) -31 ([0-9]{2}) |(0[48]|[2468][048]|[13579][26]) |(0[48]|[2468][048]|[13579][26]) 00) -02-29) $");Console.WriteLine (start date: + dt.ToString (yyyy-MM-dd));While (DT < endDay){If (... DateRegex.IsMatch (dt.ToString ("yyyy-MM-dd")){Console.WriteLine (dt.ToString ("yyyy-MM-dd") + "false");}DT = dt.AddDays (1);}If (... DateRegex.IsMatch (dt.)ToString（“yyyy-mm-dd”）））{控制台。
c++ 年月日正则表达式
c++ 年月日正则表达式在C++中，可以使用正则表达式库来匹配日期格式。
下面是示例代码，用于匹配年月日格式的字符串：c复制代码：#include <iostream> #include <regex> int main() { std::string date = "2023-07-19";std::regex pattern(R"(\d{4}-\d{2}-\d{2})");if (std::regex_match(date, pattern)) { std::cout << "匹配成功！" << std::endl; } else { std::cout << "匹配失败！" << std::endl;} return 0; }在上面的代码中，我们首先定义了一个日期字符串date，然后定义了一个正则表达式模式pattern，该模式用于匹配年月日格式的字符串。
正则表达式模式\d{4}-\d{2}-\d{2}表示匹配4位数字、破折号、2位数字、破折号和2位数字的字符串。
最后，我们使用std::regex_match()函数来检查日期字符串是否与正则表达式模式匹配。
如果匹配成功，则输出“匹配成功！”；否则输出“匹配失败！”。
#include <regex> int main() { std::string date = "2023-07-19"; std::regexpattern(R"(\d{4}-\d{2}-\d{2})"); if (std::regex_match(date, pattern)) { std::cout << "匹配成功！" << std::endl; } else { std::cout << "匹配失败！" << std::endl; } return 0; }在上面的代码中，我们首先定义了一个日期字符串date，然后定义了一个正则表达式模式pattern，该模式用于匹配年月日格式的字符串。
验证日期时间格式的正则表达式
验证⽇期时间格式的正则表达式//判断⽇期：年-⽉-⽇（2005.12.25、2005年12⽉2号、2005/10/23,2005-11-28)、年-⽉（05年12⽉）、⽉-⽇（12-30、10/30、10.30、10⽉30号）private static System.Text.RegularExpressions.Regex reg_isDate=new System.Text.RegularExpressions.Regex ("^(?:(31)(\\D)(0? [13578]|1[02])\\2|(29|30)(\\D)(0?[13-9]|1[0-2])\\5|(0?[1-9]|1\\d|2[0-8])(\\D)(0?[1-9]|1[0-2])\\8)((?:1[6-9]|[2-9]\\d)?\\d{2})$|^(29)(\\D)(0?2)\\12((?:1[6-9]|[2-9]\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:16|[2468][048]|[3579][26])00)$");/// <summary>/// 验证时间格式：12：23：34或00：00：1或8：3：42/// </summary>private static System.Text.RegularExpressions.Regex reg_isTime=new Regex(@"^((0?\d|1[0-9]|2[0-3])|((0?\d|1[0-9]|2[0-3]):(0?\d|[0-5]\d)(: (0?\d|[0-5]\d)){0,1}))$");/// <summary>/// 判断⽇期：年-⽉-⽇（2005.12.25、2005年12⽉2号、2005/10/23,2005-11-28)、年-⽉（05年12⽉）、⽉-⽇（12-30、10/30、10.30、10⽉30号）/// </summary>/// <param name="expression"></param>/// <returns></returns>public static bool IsDate(ref string expression){string text=expression;bool existDay=true;//当⽇期格式为05年12⽉时使⽤。
年月日时分秒正则表达式
年月日时分秒正则表达式
在进行数据处理和时间格式化的过程中，经常会用到正则表达式来匹配日期和时间。
下面是一些常用的年月日时分秒正则表达式： 1. 匹配年份：^[1-9]d{3}$，表示以1-9开头，后面跟3个数字的字符串，即表示1000年到9999年之间的年份。
2. 匹配月份：^(0?[1-9]|1[0-2])$，表示以0或1开头，后面跟一个数字的字符串，表示1月到12月之间的月份。
3. 匹配日子：^((0?[1-9])|((1|2)[0-9])|30|31)$，表示以0-3开头并跟一个数字，或以1或2开头并跟一个数字，或为30或31的字符串，即表示1日到31日之间的日期。
4. 匹配时间：^([01][0-9]|2[0-3]):[0-5][0-9]$，表示以0或1开头并跟一个数字，或以2开头并跟一个数字0-3，后面跟一个英文冒号，再后面跟两个数字的字符串，表示24小时制的时间。
5. 匹配日期：^(d{4})-(d{2})-(d{2})$，表示以4个数字开头，后面跟一个连字符，再后面跟2个数字，再跟一个连字符，最后再跟2个数字的字符串，表示年-月-日的日期格式。
6. 匹配日期时间：^(d{4})-(d{2})-(d{2})
([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]$，表示以4个数字开头，后面跟一个连字符，再后面跟2个数字，再跟一个连字符，再跟2个数字，再跟一个空格和24小时制的时间的字符串，表示年-月-日时:分:秒的日期时间格式。
这些正则表达式可以用于验证用户输入的日期和时间是否符合
特定的格式，也可以用于从字符串中提取日期和时间信息，方便进行数据处理和格式化。
正则应用之——日期正则表达式
正则应⽤之——⽇期正则表达式1 概述⾸先需要说明的⼀点，⽆论是Winform，还是Webform，都有很成熟的⽇历控件，⽆论从易⽤性还是可扩展性上看，⽇期的选择和校验还是⽤⽇历控件来实现⽐较好。
前⼏天在CSDN多个版块看到需要⽇期正则的帖⼦，所以整理了这篇⽂章，和⼤家⼀起讨论交流，如有遗漏或错误的地⽅，还请⼤家指正。
⽇期正则⼀般是对格式有要求，且数据不是直接由⽤户输⼊时使⽤。
因应⽤场景的不同，写出的正则也不同，复杂程度也⾃然不同。
正则的书写需要根据具体情况具体分析，⼀个基本原则就是：只写合适的，不写复杂的。
对于⽇期提取，只要能与⾮⽇期区分开，写最简单的正则即可，如\d{4}-\d{2}-\d{2}如果可以在源字符串中唯⼀定位yyyy-MM-dd格式的⽇期，则可⽤做提取。
对于验证，如果仅仅是验证字符组成及格式是没有多⼤意义的，还要加⼊对规则的校验。
由于闰年的存在，使得⽇期的校验正则变得⽐较复杂。
先来考察⼀下⽇期的有效范围以及什么是闰年。
2 ⽇期的规则2.1 ⽇期的有效范围对于⽇期的有效范围，不同的应⽤场景会有所不同。
MSDN中定义的DateTime对象的有效范围是：0001-01-01 00:00:00到9999-12-31 23:59:59。
UNIX时间戳的0按照ISO 8601规范为：1970-01-01T00:00:00Z。
⽽实际应⽤中，⽇期的范围基本上不会超出DateTime所规定的范围，所以正则验证取其中常⽤的⽇期范围即可。
2.2 什么是闰年（以下摘⾃百度百科）闰年(leap year)是为了弥补因⼈为历法规定造成的年度天数与地球实际公转周期的时间差⽽设⽴的。
补上时间差的年份为闰年。
地球绕⽇运⾏周期为365天5⼩时48分46秒（合365.24219天），即⼀（tropical year）。
公历的平年只有365⽇，⽐回归年短约0.2422 ⽇，每四年累积约⼀天，把这⼀天加于2⽉末（即2⽉29⽇），使当年时间长度变为366⽇，这⼀年就为闰年。
Python正则表达式匹配日期与时间的方法
Python正则表达式匹配⽇期与时间的⽅法下⾯给⼤家介绍下Python正则表达式匹配⽇期与时间#!/usr/bin/env python# -*- coding: utf-8 -*-__author__ = 'Randy'import refrom datetime import datetimetest_date = '他的⽣⽇是2016-12-12 14:34,是个可爱的⼩宝贝.⼆宝的⽣⽇是2016-12-21 11:34,好可爱的.'test_datetime = '他的⽣⽇是2016-12-12 14:34,是个可爱的⼩宝贝.⼆宝的⽣⽇是2016-12-21 11:34,好可爱的.'# datemat = re.search(r"(\d{4}-\d{1,2}-\d{1,2})",test_date)print mat.groups()# ('2016-12-12',)print mat.group(0)# 2016-12-12date_all = re.findall(r"(\d{4}-\d{1,2}-\d{1,2})",test_date)for item in date_all:print item# 2016-12-12# 2016-12-21# datetimemat = re.search(r"(\d{4}-\d{1,2}-\d{1,2}\s\d{1,2}:\d{1,2})",test_datetime)print mat.groups()# ('2016-12-12 14:34',)print mat.group(0)# 2016-12-12 14:34date_all = re.findall(r"(\d{4}-\d{1,2}-\d{1,2}\s\d{1,2}:\d{1,2})",test_datetime)for item in date_all:print item# 2016-12-12 14:34# 2016-12-21 11:34## 有效时间# 如这样的⽇期2016-12-35也可以匹配到.测试如下.test_err_date = '如这样的⽇期2016-12-35也可以匹配到.测试如下.'print re.search(r"(\d{4}-\d{1,2}-\d{1,2})",test_err_date).group(0)# 2016-12-35# 可以加个判断def validate(date_text):try:if date_text != datetime.strptime(date_text, "%Y-%m-%d").strftime('%Y-%m-%d'):raise ValueErrorreturn Trueexcept ValueError:# raise ValueError("错误是⽇期格式或⽇期,格式是年-⽉-⽇")return Falseprint validate(re.search(r"(\d{4}-\d{1,2}-\d{1,2})",test_err_date).group(0))# false# 其他格式匹配. 如2016-12-24与2016/12/24的⽇期格式.date_reg_exp = pile('\d{4}[-/]\d{2}[-/]\d{2}')test_str= """平安夜圣诞节2016-12-24的⽇⼦与去年2015/12/24的是有不同哦."""# 根据正则查找所有⽇期并返回matches_list=date_reg_exp.findall(test_str)# 列出并打印匹配的⽇期for match in matches_list:print match# 2016-12-24# 2015/12/24ps：下⾯看下python正则表达式中原⽣字符r的作⽤r的作⽤>>> mm = "c:\\a\\b\\c">>> mm'c:\\a\\b\\c'>>> print(mm)c:\a\b\c>>> re.match("c:\\\\",mm).group()'c:\\'>>> ret = re.match("c:\\\\",mm).group()>>> print(ret)c:\>>> ret = re.match("c:\\\\a",mm).group()>>> print(ret)c:\a>>> ret = re.match(r"c:\\a",mm).group()>>> print(ret)c:\a>>> ret = re.match(r"c:\a",mm).group()Traceback (most recent call last):File "<stdin>", line 1, in <module>AttributeError: 'NoneType' object has no attribute 'group'>>>说明Python中字符串前⾯加上 r 表⽰原⽣字符串与⼤多数编程语⾔相同，正则表达式⾥使⽤"\"作为转义字符，这就可能造成反斜杠困扰。
日期验证 正则表达式
日期验证正则表达式1.验证日期的正则表达式加入闰年的判断以及思路分析进入正题之前，我们需要澄清两个概念：一，什么是合法的日期范围？对于不同的应用场景，这个问题有不同的解释。
这里采纳MSDN中的约定：DateTime值类型表示值范围在公元（基督纪元）0001 年1 月1 日午夜12:00:00 到公元(C.E.) 9999 年12 月31 日晚上11:59:59 之间的日期和时间。
二，关于闰年的阐释。
人民教育出版社小学数学室的解释浅明易懂（mediawiki等都没说明为什么整百年份必须是400的倍数时才是闰年）：关于公历闰年是这样规定的：地球绕太阳公转一周叫做一回归年，一回归年长365日5时48分46秒。
因此，公历规定有平年和闰年，平年一年有365日，比回归年短0.2422日，四年共短0.9688日，故每四年增加一日，这一年有366日，就是闰年。
但四年增加一日比四个回归年又多0.0312日,400年后将多3.12日,故在400年中少设3个闰年,也就是在400年中只设97个闰年，这样公历年的平均长度与回归年就相近似了。
由此规定：年份是整百数的必须是400的倍数才是闰年，例如1900年、2100年就不是闰年。
清楚了以上两个概念，我们进入正题。
首先需要验证年份，显然，年份范围为0001 - 9999，匹配YYYY的正则表达式为：[0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}其中[0-9] 也可以表示为\d，但\d 不如[0-9] 直观，因此下面我将一直采用[0-9]用正则表达式验证日期的难点有二：一是大小月份的天数不同，二是闰年的考虑。
对于第一个难点，我们首先不考虑闰年，假设2月份都是28天，这样，月份和日期可以分成三种情况：1、月份为1, 3, 5, 7, 8, 10, 12，天数范围为01 - 31，匹配MM-DD的正则表达式为：(0[13578]|1[02])-(0[1-9]|[12][0-9]|3[01])2、月份为4, 6, 9, 11，天数范围为01-30，匹配MM-DD的正则表达式为：(0[469]|11)-(0[1-9]|[12][0-9]|30)3、月份为2，考虑平年情况，匹配MM-DD的正则表达式为：02-(0[1-9]|[1][0-9]|2[0-8])根据上面的成果，我们可以得到匹配平年日期格式为YYYY-MM-DD的正则表达式：([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3})-(((0[13578]|1[02])-(0[1-9]|[12][0-9]|3[01]))|((0[469]|11)-(0[1 -9]|[12][0-9]|30))|(02-(0[1-9]|[1][0-9]|2[0-8])))接着我们来解决第二个难点：闰年的考虑。
java时间正则表达式
(10|12|0?[13578])([-\/\._])(3[01]|[12][0-9]
|0?[1-9])$)|(^((1[8-9]\d{2})|([2-9]\d{3}))
([-\/\._])(11|0?[469])([-\/\._])(30|[12][0-9]
([-\/\._])(29)$)|(^([1][89][0][48])([-\/\._])
(0?2)([-\/\._])(29)$)|(^([2-9][0-9][0][48])
([-\/\._])(0?2)([-\/\._])(29)$)|(^([1][89]
[2468][048])([-\/\._])(0?2)([-\/\._])(29)$)|
1、月份为 1, 3, 5, 7, 8, 10, 12，天数范围为01 - 31，匹配MM-DD的正则表达式为：(0[13578]|1[02])-(0[1-9]|[12][0-9]|3[01])
2、月份为 4, 6, 9, 11，天数范围为 01-30，匹配MM-DD的正则表达式为：(0[469]|11)-(0[1-9]|[12][0-9]|30)
分析：
1、什么是合法的日期范围？对于不同的应用场景，这个问题有不同的解释。这里采纳MSDN中的约定：
DateTime值类型表示值范围在公元（基督纪元）0001 年 1 月 1 日午夜 12:00:00 到公元
(C.E.) 9999 年 12 月 31 日晚上 11:59:59 之间的日期和时间。
[0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}
python正则表达式获取字符串中所有的日期和时间
python正则表达式获取字符串中所有的⽇期和时间提取⽇期前的处理1.处理⽂本数据的⽇期格式统⼀化text = "2015年8⽉31⽇，衢州元⽴⾦属制品有限公司仓储公司（以下简称元⽴仓储公司）成品仓库发⽣⼀起物体打击事故，造成直接经济损失95万元。
" text1 = "2015/12/28下达⾏政处罚决定书"text2 = "2015年8⽉发⽣⼀起物体打击事故"# 对⽂本处理⼀下 # 2015-8-31 2015-12-28text = text.replace("年", "-").replace("⽉", "-").replace("⽇", " ").replace("/", "-").strip()2.提取时间的正则表达式# 2019年10⽉27⽇ 9:46:21"(\d{4}-\d{1,2}-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2})"# 2019年10⽉27⽇ 9:46""(\d{4}-\d{1,2}-\d{1,2})"# 2019年10⽉27⽇"(\d{4}-\d{1,2}-\d{1,2})"# 2019年10⽉"(\d{4}-\d{1,2})"3.对其进⾏封装def get_strtime(text):text = text.replace("年", "-").replace("⽉", "-").replace("⽇", " ").replace("/", "-").strip()text = re.sub("\s+", " ", text)t = ""regex_list = [# 2013年8⽉15⽇ 22:46:21"(\d{4}-\d{1,2}-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2})",# "2013年8⽉15⽇ 22:46""(\d{4}-\d{1,2}-\d{1,2} \d{1,2}:\d{1,2})",# "2014年5⽉11⽇""(\d{4}-\d{1,2}-\d{1,2})",# "2014年5⽉""(\d{4}-\d{1,2})",]for regex in regex_list:t = re.search(regex, text)if t:t = t.group(1)return telse:print("没有获取到有效⽇期")return tps:下⾯看下python提取字符串中⽇期import re#删除字符串中的中⽂字符def subChar(str):match=pile(u'[\u4e00-\u9fa5]')return match.sub('',str)#提取⽇期def extractDate(str):if not str:return Noneraw=subChar(str)if not raw:return None#提取前10位字符rawdate=raw[:10]datelist=re.findall("\d+",rawdate)if not datelist:return Noneif datelist.__len__()==3:if (float(datelist[0])>2099 or float(datelist[0])<1900) or float(datelist[1])>12 or float(datelist[2])>31:return Noneelse:return '-'.join(datelist)if datelist.__len__()==2:if (float(datelist[0])>2099 or float(datelist[0])<1900) or float(datelist[1])>12:return Noneelse:datelist.append('01')return '-'.join(datelist)if datelist.__len__()==1:if float(datelist[0])>20991231 or float(datelist[0])<19000101:return Noneelse:return datelist[0]return None总结以上所述是⼩编给⼤家介绍的python 正则表达式获取字符串中所有的⽇期和时间,希望对⼤家有所帮助，如果⼤家有任何疑问请给我留⾔，⼩编会及时回复⼤家的。
年月正则 yyyy-mm 判断范围
年月正则 yyyy-mm 判断范围下载提示：该文档是本店铺精心编制而成的，希望大家下载后，能够帮助大家解决实际问题。
文档下载后可定制修改，请根据实际需要进行调整和使用，谢谢！本店铺为大家提供各种类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，想了解不同资料格式和写法，敬请关注！Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you! In addition, this shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!年月正则 yyyymm 判断范围在日常工作中，我们经常会遇到需要对年月进行正则判断的情况，特别是在处理日期数据时。
1940-2099正在表达式
1940-2099的日期正则表达式无论是做网页，还在做程序，一般都会遇到对日期数据进行检验。
今天在开发过程中，总结了1940-2099年的日期正在表达式。
以“年-月-日”的格式进行检查。
1.检验年份1940 到2009：正则表达式：^((19[4-9][0-9])|(20[\d][\d]))$例子：比如在java代码中检验1879年是否符合检验Eg：publicclass RegularDemo {publicstaticvoid main(String args[]){String year="1978";System.out.println(year.matches("^((19[4-9][0-9])|(20 [\\d][\\d]))$"));}}}示例执行的结果会是：true表示检验成功，如果把年份换成1000等不在范围内的数据，执行的结果将会是false。
2.检验大月日期：正则表达式：^((0?[13578])|(1[02]))-((0?[1-9])|([12]\\d)|(3[01]))$（格式“月-日”）这里检验的是字符串是否是大月的日期这里的条件有两个：大月，格式为”月-日“。
比如1-18,1月份是大月，格式也正，所有检验成功，如果是2-4，检验失败，2月不是大月，如果3-32 或者13-4,0-8等格式检验都失败，因为他们的格式不正确。
当然也可以检验03-04这样的格式，也能通过检验。
Eg.publicclass RegularDemo {publicstaticvoid main(String args[]){ Stringyear="3-9";System.out.println(year.matches("^^((0?[13 578])|(1[02]))-((0?[1-9])|([12]\\d)|(3[01]))$$"));}}程序检验通过，输出结果：true同理由检验小月,二月正则表达式：小月正则表达式：^((0?[469])|(11))-((0?[1-9])|([12]\\d)|(30))$二月正则表达式：(0?2-0?[0-9])|(0?2-[12]\\d这里与大月差不多，就不说明了。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
日期正则表达式~转
2009-03-29 19:17
一、简单的
日期判断（YYYY/MM/DD）：^\d{4}(\-|\/|\.)
\d{1,2}\1\d{1,2}$
二、演化的日期判断（YYYY/MM/DD|
YY/MM/DD）：
^(^(\d{4}|\d{2})(\-|\/|\.)\d{1,2}\3\d{1,2}
$)|(^\d{4}年\d{1,2}月\d{1,2}日$)$
三、加入闰年的判断的：
实例：
^((((1[6-9]|[2-9]\d)\d{2})-(0?[13578]|1 [02])-(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]
\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]| [12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?
[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]| [2468][048]|[13579][26])|((16|[2468][048]| [3579][26])00))-0?2-29-))$
分析：
1、什么是合法的日期范围？对于不同的应用场景，这个问题有不同的解释。
这里采纳MSDN中
的约定：
DateTime值类型表示值范围在公元（基督纪元
）0001 年 1 月 1 日午夜12:00:00 到公元
(C.E.) 9999 年12 月31 日晚上11:59:59 之间的日期和时间。
2、关于闰年的阐释。
关于公历闰年是这样规定的：地球绕太阳公转
一周叫做一回归年，一回归年长365日5时48分46秒。
因此，公历规定有平年和闰年，平年一
年有365日，比回归年短0.2422日，四年共短
0.9688日，故每四年增加一日，这一年有366日，就是闰年。
但四年增加一日比四个回归年又
多0.0312日,400年后将多3.12日,故在400年中少设3个闰年,也就是在400年中只设97个闰年，这样公历年的平均长度与回归年就相近似了。
由此规定：年份是整百数的必须是400的倍数才是闰年，例如1900年、2100年就不是闰年。
首先需要验证年份，显然，年份范围为0001 - 9999，匹配YYYY的正则表达式为：
[0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]
{1}[1-9][0-9]{2}|[1-9][0-9]{3}
其中[0-9] 也可以表示为\d，但\d 不如[0-9] 直观，因此下面我将一直采用[0-9]
用正则表达式验证日期的难点有二：一是大小
月份的天数不同，二是闰年的考虑。
对于第一个难点，我们首先不考虑闰年，假设2 月份都是28天，这样，月份和日期可以分成三
种情况：
1、月份为1, 3, 5, 7, 8, 10, 12，天数范围为
01 - 31，匹配MM-DD的正则表达式为：
(0[13578]|1[02])-(0[1-9]|[12][0-9]|3[01])
2、月份为4, 6, 9, 11，天数范围为01-30，匹
配MM-DD的正则表达式为：
(0[469]|11)-(0[1-9]|[12][0-9]|30)
3、月份为2，考虑平年情况，匹配MM-DD的正则表达式为：
02-(0[1-9]|[1][0-9]|2[0-8])
根据上面的成果，我们可以得到匹配平年日期
格式为YYYY-MM-DD的正则表达式：
([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]
{1}[1-9][0-9]{2}|[1-9][0-9]{3})-(((0[13578]
|1[02])-(0[1-9]|[12][0-9]|3[01]))|((0[469]
|11)-(0[1-9]|[12][0-9]|30))|(02-(0[1-9]|[1]
[0-9]|2[0-8])))
接着我们来解决第二个难点：闰年的考虑。
根
据闰年的定义，我们可以将闰年分为两类：
1、能被4整除但不能被100整除的年份。
寻找后两位的变化规律，可以很快得到下面的正则匹配：
([0-9]{2})(0[48]|[2468][048]|[13579][26])
2、能被400整除的年份。
能被400整除的数肯定能被100整除，因此后两位肯定是00，我们只要保证前两位能被4整除即可，相应的正则表达式为：
(0[48]|[2468][048]|[3579][26])00
2.最强验证日期的正则表达式,添加了闰年的验证
这个日期正则表达式支持
YYYY-MM-DD
YYYY/MM/DD
YYYY_MM_DD
YYYY.MM.DD的形式
match : 2008-2-29 2008/02/29
not match : 2008-2-30 2007-2-29
完整的正则表达式如下:
((^((1[8-9]\d{2})|([2-9]\d{3}))([-\/\._])
(10|12|0?[13578])([-\/\._])(3[01]|[12][0-9] |0?[1-9])$)|(^((1[8-9]\d{2})|([2-9]\d{3})) ([-\/\._])(11|0?[469])([-\/\._])(30|[12][0-9] |0?[1-9])$)|(^((1[8-9]\d{2})|([2-9]\d{3})) ([-\/\._])(0?2)([-\/\._])(2[0-8]|1[0-9]|0?[1- 9])$)|(^([2468][048]00)([-\/\._])(0?2)([-\/ \._])(29)$)|(^([3579][26]00)([-\/\._])(0?2) ([-\/\._])(29)$)|(^([1][89][0][48])([-\/\._]) (0?2)([-\/\._])(29)$)|(^([2-9][0-9][0][48]) ([-\/\._])(0?2)([-\/\._])(29)$)|(^([1][89] [2468][048])([-\/\._])(0?2)([-\/\._])(29)$)| (^([2-9][0-9][2468][048])([-\/\._])(0?2)([-\/ \._])(29)$)|(^([1][89][13579][26])([-\/\._]) (0?2)([-\/\._])(29)$)|(^([2-9][0-9][13579]
[26])([-\/\._])(0?2)([-\/\._])(29)$))
闰年的2月份有29天，因此匹配闰年日期格式为YYYY-MM-DD的正则表达式为：
(([0-9]{2})(0[48]|[2468][048]|[13579][26])
|((0[48]|[2468][048]|[3579][26])00))-02-29
最后，将平年和闰年的日期验证表达式合并，
我们得到最终的验证日期格式为YYYY-MM-DD 的正则表达式为：
(([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]
{1}[1-9][0-9]{2}|[1-9][0-9]{3})-(((0[13578]
|1[02])-(0[1-9]|[12][0-9]|3[01]))|((0[469]
|11)-(0[1-9]|[12][0-9]|30))|(02-(0[1-9]|[1]
[0-9]|2[0-8]))))|((([0-9]{2})(0[48]|[2468]
[048]|[13579][26])|((0[48]|[2468][048]|
[3579][26])00))-02-29)
DD/MM/YYYY格式的正则验证表达式为：(((0[1-9]|[12][0-9]|3[01])/((0[13578]|1 [02]))|((0[1-9]|[12][0-9]|30)/(0[469]|11))|
(0[1-9]|[1][0-9]|2[0-8])/(02))/([0-9]{3}[1-
9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]
{2}|[1-9][0-9]{3}))|(29/02/(([0-9]{2})(0 [48]|[2468][048]|[13579][26])|((0[48]| [2468][048]|[3579][26])00)))。