`
leonardleonard
  • 浏览: 801408 次
社区版块
存档分类
最新评论

一个常用的正则表达验证类

正则表达式CC++C# 
阅读更多
这是

風語·深蓝

很早以前写的一个正则表达式验证工具类，包含了一些常见的校验和支持自定义的正则表达式匹配，可以选择完全匹配，也可以获取所有匹配项。曾用它仿造Eclispe下的正则表达式插件写过一个工具。因为最近突然有几个朋友都在问这方面的问题，干脆就把代码贴出来好了。
  1. using System;
  2. using System.Collections;
  3. using System.Text.RegularExpressions;
  5. namespace Xrinehart.Framework.Common.Validate
  6. {
  7.     /**//// <summary>
  8.     /// RegularMatch 的摘要说明。
  9.     /// </summary>    
  10.     public class RegularMatch
  11.     {
  12.         private string _String;
  13.         private bool _IsEntirety;
  15.         /**//// <summary>
  16.         /// 可以进行判断的类型
  17.         /// </summary>
  18.         public enum Operation
  19.         {
  20.             Byte, SByte, Int16, Int32, Int64, Single, Double, Boolean, Char, Decimal, DateTime, Date, Time,
  21.             EMail, URL, ChinaPhone, ChineseWord, ChinesePostalCode, Number, StringModel_01, StringModel_02, WideWord, NarrowWord, IPAddress,
  22.             ChineseMobile, ChineseID
  23.         };
  25.         public RegularMatch() { }
  27.         用于判断字符串是否是对应类型（默认为包含匹配）#region 用于判断字符串是否是对应类型（默认为包含匹配）
  28.         public bool IsAccordType(string strVerifyString, Operation op)
  29.         {
  30.             return IsAccordType(strVerifyString, op, false);
  31.         }
  32.         #endregion
  34.         用于判断字符串是否是对应类型（或是否包含对应类型的字符）#region 用于判断字符串是否是对应类型（或是否包含对应类型的字符）
  35.         /**//// <summary>
  36.         /// 用于判断字符串是否是对应类型
  37.         /// </summary>
  38.         /// <param name="strVerifyString">String，需要判断的字符串</param>
  39.         /// <param name="op">Operation枚举，用于选择需要进行的操作</param>
  40.         /// <param name="IsEntirety">Boolean，判断是完全匹配还是包含匹配模式（仅适用于非类型判断时）</param>
  41.         /// <returns></returns>
  42.         public bool IsAccordType(string strVerifyString, Operation op, bool IsEntirety)
  43.         {
  44.             _String = strVerifyString;
  45.             _IsEntirety = IsEntirety;
  47.             switch (op)
  48.             {
  49.                 case Operation.Byte:
  50.                     {
  51.                         return IsByte();
  52.                     }
  53.                 case Operation.SByte:
  54.                     {
  55.                         return IsSByte();
  56.                     }
  57.                 case Operation.Int16:
  58.                     {
  59.                         return IsInt16();
  60.                     }
  61.                 case Operation.Int32:
  62.                     {
  63.                         return IsInt32();
  64.                     }
  65.                 case Operation.Int64:
  66.                     {
  67.                         return IsInt64();
  68.                     }
  69.                 case Operation.Single:
  70.                     {
  71.                         return IsSingle();
  72.                     }
  73.                 case Operation.Double:
  74.                     {
  75.                         return IsDouble();
  76.                     }
  77.                 case Operation.Boolean:
  78.                     {
  79.                         return IsBoolean();
  80.                     }
  81.                 case Operation.Char:
  82.                     {
  83.                         return IsChar();
  84.                     }
  85.                 case Operation.Decimal:
  86.                     {
  87.                         return IsDecimal();
  88.                     }
  89.                 case Operation.DateTime:
  90.                     {
  91.                         return IsDateTime();
  92.                     }
  93.                 case Operation.Date:
  94.                     {
  95.                         return IsDate();
  96.                     }
  97.                 case Operation.Time:
  98.                     {
  99.                         return IsTime();
  100.                     }
  101.                 case Operation.IPAddress:
  102.                     {
  103.                         return IsIPAddress();
  104.                     }
  105.                 case Operation.ChinaPhone:
  106.                     {
  107.                         return IsChinaPhone();
  108.                     }
  109.                 case Operation.ChinesePostalCode:
  110.                     {
  111.                         return IsChinesePostalCode();
  112.                     }
  113.                 case Operation.ChineseMobile:
  114.                     {
  115.                         return IsChineseMobile();
  116.                     }
  117.                 case Operation.EMail:
  118.                     {
  119.                         return IsEmail();
  120.                     }
  121.                 case Operation.URL:
  122.                     {
  123.                         return IsURL();
  124.                     }
  125.                 case Operation.ChineseWord:
  126.                     {
  127.                         return IsChineseWord();
  128.                     }
  129.                 case Operation.Number:
  130.                     {
  131.                         return IsNumber();
  132.                     }
  133.                 case Operation.StringModel_01:
  134.                     {
  135.                         return IsStringModel_01();
  136.                     }
  137.                 case Operation.StringModel_02:
  138.                     {
  139.                         return IsStringModel_02();
  140.                     }
  141.                 case Operation.WideWord:
  142.                     {
  143.                         return IsWideWord();
  144.                     }
  145.                 case Operation.NarrowWord:
  146.                     {
  147.                         return IsNarrowWord();
  148.                     }
  149.                 case Operation.ChineseID:
  150.                     {
  151.                         return IsChineseID();
  152.                     }
  153.                 default:
  154.                     {
  155.                         return false;
  156.                     }
  157.             }
  158.         }
  159.         #endregion
  161.         具体验证方法#region 具体验证方法
  163.         是否Byte类型（8 位的无符号整数）： 0 和 255 之间的无符号整数#region 是否Byte类型（8 位的无符号整数）： 0 和 255 之间的无符号整数
  164.         /**//// <summary>
  165.         /// 是否Byte类型（8 位的无符号整数）： 0 和 255 之间的无符号整数
  166.         /// </summary>
  167.         /// <returns>Boolean</returns>
  168.         protected bool IsByte()
  169.         {
  170.             try
  171.             {
  172.                 Byte.Parse(_String);
  173.             }
  174.             catch
  175.             {
  176.                 return false;
  177.             }
  178.             return true;
  179.         }
  180.         #endregion
  182.         是否SByte类型（8 位的有符号整数）： -128 到 +127 之间的整数#region 是否SByte类型（8 位的有符号整数）： -128 到 +127 之间的整数
  183.         /**//// <summary>
  184.         /// 是否SByte类型（8 位的有符号整数）： -128 到 +127 之间的整数
  185.         /// </summary>
  186.         /// <returns>Boolean</returns>
  187.         protected bool IsSByte()
  188.         {
  189.             try
  190.             {
  191.                 SByte.Parse(_String);
  192.             }
  193.             catch
  194.             {
  195.                 return false;
  196.             }
  197.             return true;
  198.         }
  199.         #endregion
  201.         是否Int16类型（16 位的有符号整数）： -32768 到 +32767 之间的有符号整数#region 是否Int16类型（16 位的有符号整数）： -32768 到 +32767 之间的有符号整数
  202.         /**//// <summary>
  203.         /// 是否Int16类型（16 位的有符号整数）： -32768 到 +32767 之间的有符号整数
  204.         /// </summary>
  205.         /// <returns>Boolean</returns>
  206.         protected bool IsInt16()
  207.         {
  208.             try
  209.             {
  210.                 Int16.Parse(_String);
  211.             }
  212.             catch
  213.             {
  214.                 return false;
  215.             }
  216.             return true;
  217.         }
  218.         #endregion
  220.         是否Int32类型（32 位的有符号整数）：-2,147,483,648 到 +2,147,483,647 之间的有符号整数#region 是否Int32类型（32 位的有符号整数）：-2,147,483,648 到 +2,147,483,647 之间的有符号整数
  221.         /**//// <summary>
  222.         /// 是否Int32类型（32 位的有符号整数）：-2,147,483,648 到 +2,147,483,647 之间的有符号整数
  223.         /// </summary>
  224.         /// <returns>Boolean</returns>
  225.         protected bool IsInt32()
  226.         {
  227.             try
  228.             {
  229.                 Int32.Parse(_String);
  230.             }
  231.             catch
  232.             {
  233.                 return false;
  234.             }
  235.             return true;
  236.         }
  237.         #endregion
  239.         是否Int64类型（64 位的有符号整数）： -9,223,372,036,854,775,808 到 +9,223,372,036,854,775,807 之间的整数#region 是否Int64类型（64 位的有符号整数）： -9,223,372,036,854,775,808 到 +9,223,372,036,854,775,807 之间的整数
  240.         /**//// <summary>
  241.         /// 是否Int64类型（64 位的有符号整数）： -9,223,372,036,854,775,808 到 +9,223,372,036,854,775,807 之间的整数
  242.         /// </summary>
  243.         /// <returns>Boolean</returns>
  244.         protected bool IsInt64()
  245.         {
  246.             try
  247.             {
  248.                 Int64.Parse(_String);
  249.             }
  250.             catch
  251.             {
  252.                 return false;
  253.             }
  254.             return true;
  255.         }
  256.         #endregion
  258.         是否Single类型（单精度（32 位）浮点数字）： -3.402823e38 和 +3.402823e38 之间的单精度 32 位数字#region 是否Single类型（单精度（32 位）浮点数字）： -3.402823e38 和 +3.402823e38 之间的单精度 32 位数字
  259.         /**//// <summary>
  260.         /// 是否Single类型（单精度（32 位）浮点数字）： -3.402823e38 和 +3.402823e38 之间的单精度 32 位数字
  261.         /// </summary>
  262.         /// <returns>Boolean</returns>
  263.         protected bool IsSingle()
  264.         {
  265.             try
  266.             {
  267.                 Single.Parse(_String);
  268.             }
  269.             catch
  270.             {
  271.                 return false;
  272.             }
  273.             return true;
  274.         }
  275.         #endregion
  277.         是否Double类型（单精度（64 位）浮点数字）： -1.79769313486232e308 和 +1.79769313486232e308 之间的双精度 64 位数字#region 是否Double类型（单精度（64 位）浮点数字）： -1.79769313486232e308 和 +1.79769313486232e308 之间的双精度 64 位数字
  278.         /**//// <summary>
  279.         /// 是否Double类型（单精度（64 位）浮点数字）： -1.79769313486232e308 和 +1.79769313486232e308 之间的双精度 64 位数字
  280.         /// </summary>
  281.         /// <returns>Boolean</returns>
  282.         protected bool IsDouble()
  283.         {
  284.             try
  285.             {
  286.                 Double.Parse(_String);
  287.             }
  288.             catch
  289.             {
  290.                 return false;
  291.             }
  292.             return true;
  293.         }
  294.         #endregion
  296.         是否Boolean类型（布尔值）：true 或 false#region 是否Boolean类型（布尔值）：true 或 false
  297.         /**//// <summary>
  298.         /// 是否Double类型（单精度（64 位）浮点数字）： -1.79769313486232e308 和 +1.79769313486232e308 之间的双精度 64 位数字
  299.         /// </summary>
  300.         /// <returns>Boolean</returns>
  301.         protected bool IsBoolean()
  302.         {
  303.             try
  304.             {
  305.                 Boolean.Parse(_String);
  306.             }
  307.             catch
  308.             {
  309.                 return false;
  310.             }
  311.             return true;
  312.         }
  313.         #endregion
  315.         是否Char类型（Unicode（16 位）字符）：该 16 位数字的值范围为从十六进制值 0x0000 到 0xFFFF#region 是否Char类型（Unicode（16 位）字符）：该 16 位数字的值范围为从十六进制值 0x0000 到 0xFFFF
  316.         /**//// <summary>
  317.         /// 是否Char类型（Unicode（16 位）字符）：该 16 位数字的值范围为从十六进制值 0x0000 到 0xFFFF
  318.         /// </summary>
  319.         /// <returns>Boolean</returns>
  320.         protected bool IsChar()
  321.         {
  322.             try
  323.             {
  324.                 Char.Parse(_String);
  325.             }
  326.             catch
  327.             {
  328.                 return false;
  329.             }
  330.             return true;
  331.         }
  332.         #endregion
  334.         是否Char类型（96 位十进制值）：从正 79,228,162,514,264,337,593,543,950,335 到负 79,228,162,514,264,337,593,543,950,335 之间的十进制数#region 是否Char类型（96 位十进制值）：从正 79,228,162,514,264,337,593,543,950,335 到负 79,228,162,514,264,337,593,543,950,335 之间的十进制数
  335.         /**//// <summary>
  336.         /// 是否Char类型（96 位十进制值）：从正 79,228,162,514,264,337,593,543,950,335 到负 79,228,162,514,264,337,593,543,950,335 之间的十进制数
  337.         /// </summary>
  338.         /// <returns>Boolean</returns>
  339.         protected bool IsDecimal()
  340.         {
  341.             try
  342.             {
  343.                 Decimal.Parse(_String);
  344.             }
  345.             catch
  346.             {
  347.                 return false;
  348.             }
  349.             return true;
  350.         }
  351.         #endregion
  353.         是否DateTime类型（表示时间上的一刻）： 范围在公元（基督纪元）0001 年 1 月 1 日午夜 12:00:00 到公元 (C.E.) 9999 年 12 月 31 日晚上 11:59:59 之间的日期和时间#region 是否DateTime类型（表示时间上的一刻）： 范围在公元（基督纪元）0001 年 1 月 1 日午夜 12:00:00 到公元 (C.E.) 9999 年 12 月 31 日晚上 11:59:59 之间的日期和时间
  354.         /**//// <summary>
  355.         /// 是否DateTime类型（表示时间上的一刻）： 范围在公元（基督纪元）0001 年 1 月 1 日午夜 12:00:00 到公元 (C.E.) 9999 年 12 月 31 日晚上 11:59:59 之间的日期和时间
  356.         /// </summary>
  357.         /// <returns>Boolean</returns>
  358.         protected bool IsDateTime()
  359.         {
  360.             try
  361.             {
  362.                 DateTime.Parse(_String);
  363.             }
  364.             catch
  365.             {
  366.                 return false;
  367.             }
  368.             return true;
  369.         }
  370.         #endregion
  372.         是否Date类型（表示时间的日期部分）： 范围在公元（基督纪元）0001 年 1 月 1 日 到公元 (C.E.) 9999 年 12 月 31 日之间的日期#region 是否Date类型（表示时间的日期部分）： 范围在公元（基督纪元）0001 年 1 月 1 日 到公元 (C.E.) 9999 年 12 月 31 日之间的日期
  373.         /**//// <summary>
  374.         /// 是否Date类型（表示时间的日期部分）： 范围在公元（基督纪元）0001 年 1 月 1 日 到公元 (C.E.) 9999 年 12 月 31 日之间的日期
  375.         /// </summary>
  376.         /// <returns>Boolean</returns>
  377.         protected bool IsDate()
  378.         {
  379.             DateTime Value;
  380.             try
  381.             {
  382.                 Value = DateTime.Parse(_String);
  383.             }
  384.             catch
  385.             {
  386.                 return false;
  387.             }
  388.             if (Value.Date.ToString() == _String)
  389.             {
  390.                 return true;
  391.             }
  392.             else
  393.             {
  394.                 return false;
  395.             }
  396.         }
  397.         #endregion
  399.         是否Time类型（表示时间部分HHMMSS）： 范围在夜 12:00:00 到晚上 11:59:59 之间的时间#region 是否Time类型（表示时间部分HHMMSS）： 范围在夜 12:00:00 到晚上 11:59:59 之间的时间
  400.   &
分享到：
| 设计高可用和高负载的网站系统
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    C# 正则表达验证类

    例如，要验证一个邮箱地址的格式，我们可以编写一个简单的正则表达式： ```csharp string emailRegex = @"^\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$"; bool isValidEmail = Regex.IsMatch(input, emailRegex...

    正则表达式验证器是对正则表达的验证

    本软件是一个用Java编写的正则表达式验证器，它的主要功能是帮助用户验证自定义的正则表达式是否能够正确匹配指定的字符串。 这个验证器分为两个输入框：第一个输入框用于输入正则表达式，用户可以在这里编写自己的...

    常用正则工具类

    - 在Java项目中，通常会封装一个工具类，集合常用的正则表达式和验证方法，方便复用。 - 这样的工具类可能包含方法如：`isEmail(String input)`验证邮箱格式，`isPhone(String input)`验证手机号码格式，`isIDCard...

    注册邮箱验证、手机号验证等正则表达验证

    在“注册邮箱验证、手机号验证等正则表达验证”这个主题中，我们将探讨如何使用正则表达式来验证用户的邮箱地址和手机号码。 1. 邮箱验证： 邮箱地址通常由用户名、@符号、域名和顶级域组成。一个基本的邮箱正则...

    js正则表达页面验证

    ### js正则表达页面验证知识点详解 #### 一、引言 在Web开发过程中，为了确保数据的有效性和安全性，前端表单验证变得尤为重要。通过JavaScript（简称JS）结合正则表达式进行表单验证是一种常见且高效的方式。本文...

    ios-HZQRegexTestter(正则表达验证工具类,满足大众开发者验证需求，已封装且一句话验证。).zip

    正则表达式验证工具类，满足大众开发者验证需求，已封装且一句话即可验证，主要包括： /** * 1.用户名 - 2.密码 （英文、数字都可，且不包含特殊字符 */ (BOOL)validateStrWithRange:(NSString *)range str:...

    正则表达式验证器（附源代码）

    在“正则表达式验证器”项目中，源代码很可能是围绕这些方法构建的，提供了一个用户界面，允许用户输入正则表达式和测试字符串，然后显示匹配结果。通过这个工具，开发者可以快速测试正则表达式的正确性，避免在实际...

    8个最基本的正则表达

    这个正则表达式确保字符串只包含这些字符，并且至少有一个字符。 5. 匹配一个 Email：`/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/ 这个正则表达式用于验证电子邮件地址的格式。它包括用户名部分（允许字母...

    正则表达式验证器下载

    正则表达式验证器，可以验证你的表达正确与否，更快更方便你写好正则表达式！

    常用正则表达试好东西

    该模式可以匹配任意一个中文字符。`[\u4e00-\u9fa5]` 表示 Unicode 范围内的中文字符。 #### 匹配全角字符 ```regex [^\x00-\xff] ``` 此模式用来匹配非半角字符，即全角字符或特殊字符等。`\x00-\xff` 包含了 ...

    JS常用正则表达式及验证时间的正则表达式

    验证一个字符串是否仅由字母和数字组成的正则表达式为：`/^[a-zA-Z0-9]*$/`。 10. 检验18位身份证号码： 身份证号码一般为18位，前6位是地区代码，接下来的8位是出生日期码，然后是3位顺序码，最后一位是校验码。...

    常用正则表达式集合

    - **元字符**：在正则表达式中，有一些特殊字符，如`.`（匹配任意字符，除了换行符）、`*`（匹配前一个字符0次或无限次）等，它们被称为元字符。 - **量词**：量词用于指定匹配次数，例如`+`（匹配1次或无限次）、...

    正则表达js验证范例PDF

    以上介绍了多个常用的正则表达式函数及其具体实现方式，它们可以帮助开发者在实际项目中高效地完成各种数据验证任务。通过合理运用这些函数，可以极大地提高前端表单的用户体验，同时减少因输入错误而导致的后端...

    正则表达生成工具

    "正则表达生成工具"正是为了解决手动构造正则表达式困难而设计的一款实用软件，它可以自动生成常见的正则表达式模式，极大地提高了工作效率。 首先，让我们深入了解一下正则表达式的概念。正则表达式由一系列字符和...

    正则验证规则，最全，最实用

    描述中提到的"最全最实用的正则验证插件，含调用示例"可能指的是一个JavaScript库或者工具，它提供了预设的正则表达式模式，并且包含了如何在实际项目中调用和应用这些规则的示例代码。例如，`vstorly.js`可能是这个...

    Java JDK正则表达

    - 此示例中，我们使用了一个较为简单的正则表达式来匹配日期。该表达式`(\d{4})[-/.](\d{2})[-/.](\d{2})`用于匹配标准的日期格式，包括年、月、日，并且允许使用破折号、斜杠或点作为分隔符。 - 使用`Matcher`对象...

    正则表达验证

    标题：正则表达验证 描述：常用的正则表达式，对于页面的限制输入减少很多的编码工作。 在网页开发中，正则表达式是处理文本数据的重要工具之一，尤其是在表单验证方面，它能帮助开发者高效地控制用户输入的数据...

Magicbox
Global site tag (gtag.js) - Google Analytics