Regex 类 (System.Text.RegularExpressions)

.NET Framework 类库

Regex 类

更新：2007 年 11 月

表示不可变的正则表达式。

命名空间： System.Text.RegularExpressions
程序集： System（在 System.dll 中）

语法

Visual Basic（声明）

<SerializableAttribute> _
Public Class Regex _
    Implements ISerializable

Visual Basic (用法)

Dim instance As Regex

[SerializableAttribute]
public class Regex : ISerializable

Visual C++

[SerializableAttribute]
public ref class Regex : ISerializable

/** @attribute SerializableAttribute */ 
public class Regex implements ISerializable

JScript

public class Regex implements ISerializable

备注

Regex 类包含若干 static（在 Visual Basic 中为 Shared）方法，使您无需显式创建 Regex 对象即可使用正则表达式。在 .NET Framework 2.0 版中，将缓存通过调用静态方法而编译的正则表达式，而不会缓存通过调用实例方法而编译的正则表达式。默认情况下，正则表达式引擎将缓存 15 个最近使用的静态正则表达式。因此，在过度地依赖一组固定的正则表达式来提取、修改或验证文本的应用程序中，您可能更愿意调用这些静态方法，而不是其相应的实例方法。IsMatch、Match、Matches、Replace 和 Split 方法的静态重载可用。

说明：
对应用程序来说，如果 15 个静态正则表达式的默认缓存大小不够用，则可以通过修改 CacheSize 属性的值来增加缓存大小。

示例

下面的代码示例演示如何使用正则表达式检查字符串是否具有表示货币值的正确格式。注意，如果使用 ^ 和 $ 封闭标记，则指示整个字符串（而不只是子字符串）都必须匹配正则表达式。

Visual Basic

Imports System.Text.RegularExpressions

Public Module Test

   Public Sub Main()
      ' Define a regular expression for currency values.
      Dim rx As New Regex("^-?\d+(\.\d{2})?$")

      ' Define some test strings.
      Dim tests() As String = {"-42", "19.99", "0.001", "100 USD", _
                               ".34", "0.34", "1,052.21"}

      ' Check each test string against the regular expression.
      For Each test As String In tests
         If rx.IsMatch(test) Then
            Console.WriteLine("{0} is a currency value.", test)
         Else
            Console.WriteLine("{0} is not a currency value.", test)
         End If
      Next
   End Sub
End Module
' The example displays the following output to the console:
'      -42 is a currency value.
'      19.99 is a currency value.
'      0.001 is not a currency value.
'      100 USD is not a currency value.
'      .34 is not a currency value.
'      0.34 is a currency value.
'      1,052.21 is not a currency value.

using System;
using System.Text.RegularExpressions;

public class Test
{
   public static void Main ()
   {
      // Define a regular expression for currency values.
         Regex rx = new Regex(@"^-?\d+(\.\d{2})?$");
          
         // Define some test strings.
         string[] tests = {"-42", "19.99", "0.001", "100 USD", 
                           ".34", "0.34", "1,052.21"};
          
         // Check each test string against the regular expression.
         foreach (string test in tests)
         {
            if (rx.IsMatch(test))
            {
               Console.WriteLine("{0} is a currency value.", test);
            }
            else
            {
               Console.WriteLine("{0} is not a currency value.", test);
            }
         }
   }    
}
// The example displays the following output to the console:
//       -42 is a currency value.
//       19.99 is a currency value.
//       0.001 is not a currency value.
//       100 USD is not a currency value.
//       .34 is not a currency value.
//       0.34 is a currency value.
//       1,052.21 is not a currency value.

Visual C++

#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{

   // Define a regular expression for currency values.
   Regex^ rx = gcnew Regex( "^-?\\d+(\\.\\d{2})?$" );

   // Define some test strings.
   array<String^>^tests = {"-42","19.99","0.001","100 USD"};

   // Check each test string against the regular expression.
   System::Collections::IEnumerator^ myEnum = tests->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ test = safe_cast<String^>(myEnum->Current);
      if ( rx->IsMatch( test ) )
      {
         Console::WriteLine( "{0} is a currency value.", test );
      }
      else
      {
         Console::WriteLine( "{0} is not a currency value.", test );
      }
   }
}

import System.*;
import System.Text.RegularExpressions.*;

public class Test
{
    public static void main(String[] args)
    {
        // Define a regular expression for currency values.
        Regex rx = new Regex("^-?\\d+(\\.\\d{2})?$");

        // Define some test strings.
        String tests[] =  { "-42", "19.99", "0.001", "100 USD" };

        // Check each test string against the regular expression.
        for (int iCtr = 0; iCtr < tests.get_Length(); iCtr++) {
            String test = (String)tests.get_Item(iCtr);
            if (rx.IsMatch(test)) {
                Console.WriteLine("{0} is a currency value.", test);
            }
            else {
                Console.WriteLine("{0} is not a currency value.", test);
            }
        }
    } //main 
} //Test

下面的代码示例演示如何使用正则表达式检查字符串中重复出现的词。注意如何使用 (?<word>) 构造来命名组，以及稍后如何使用 (\k<word>) 在表达式中引用该组。

Visual Basic

Imports System
Imports System.Text.RegularExpressions

Public Module Test

    Public Sub Main()
        ' Define a regular expression for repeated words.
        Dim rx As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumped over the lazy dog dog."

        ' Find matches.
        Dim matches As MatchCollection = rx.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
    End Sub
End Module
' The example produces the following output to the console:
'       3 matches found in:
'          The the quick brown fox  fox jumped over the lazy dog dog.
'       'The' repeated at positions 0 and 4
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 50 and 54

using System;
using System.Text.RegularExpressions;

public class Test
{

    public static void Main ()
    {

        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.        
        string text = "The the quick brown fox  fox jumped over the lazy dog dog.";

        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}", 
                          matches.Count, 
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",  
                              groups["word"].Value, 
                              groups[0].Index, 
                              groups[1].Index);
        }

    }
    
}
// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumped over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54

Visual C++

#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
   // Define a regular expression for repeated words.
   Regex^ rx = gcnew Regex( "\\b(?<word>\\w+)\\s+(\\k<word>)\\b",static_cast<RegexOptions>(RegexOptions::Compiled | RegexOptions::IgnoreCase) );

   // Define a test string.        
   String^ text = "The the quick brown fox  fox jumped over the lazy dog dog.";

   // Find matches.
   MatchCollection^ matches = rx->Matches( text );

   // Report the number of matches found.
   Console::WriteLine( "{0} matches found.", matches->Count );

   // Report on each match.
   for each (Match^ match in matches)
   {
      String^ word = match->Groups["word"]->Value;
      int index = match->Index;
      Console::WriteLine("{0} repeated at position {1}", word, index);   
   }
}

import System.*;
import System.Text.RegularExpressions.*;

public class Test
{
    public static void main(String[] args)
    {
        // Define a regular expression for repeated words.
        Regex rx = new Regex("\\b(?<word>\\w+)\\s+(\\k<word>)\\b", 
            RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.        
        String text = "The the quick brown fox  fox jumped over the "
            + "lazy dog dog.";

        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found.", (Int32)matches.get_Count());

        // Report on each match.
        for (int iCtr = 0; iCtr < matches.get_Count(); iCtr++) {
            Match match = matches.get_Item(iCtr);
            String word = match.get_Groups().get_Item("word").get_Value();
            int index = match.get_Index();
            Console.WriteLine("{0} repeated at position {1}", word, 
                (Int32)index);
        }
    } //main       
} //Test

继承层次结构

线程安全

Regex 类是不可变（只读）的，并且具有固有的线程安全性。可以在任何线程上创建 Regex 对象，并在线程间共享。有关更多信息，请参见线程安全。

平台

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC, Xbox 360

.NET Framework 和 .NET Compact Framework 并不是对每个平台的所有版本都提供支持。有关支持的版本的列表，请参见.NET Framework 系统要求。

版本信息

.NET Framework

受以下版本支持：3.5、3.0、2.0、1.1、1.0

.NET Compact Framework

受以下版本支持：3.5、2.0、1.0

XNA Framework

受以下版本支持：2.0、1.0

另请参见

参考

Regex 成员

System.Text.RegularExpressions 命名空间

其他资源

.NET Framework 正则表达式

正则表达式语言元素