Regex.Split 方法

參考

定義

命名空間:: System.Text.RegularExpressions

組件:: System.Text.RegularExpressions.dll

組件:: System.dll

組件:: netstandard.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

將輸入字串分割成正則表示式比對所定義位置的子字串陣列。

多載

Split(String, String, RegexOptions, TimeSpan)	將輸入字串分割成指定正則表示式模式所定義位置的子字串陣列。其他參數會指定修改比對作業的選項，如果找不到相符專案，則會指定超時時間間隔。
Split(String, String, RegexOptions)	將輸入字串分割成指定正則表示式模式所定義位置的子字串陣列。指定的選項會修改比對作業。
Split(String, Int32, Int32)	將指定的最大次數的輸入字串分割成子字串陣列，該陣列位於 Regex 建構函式中指定的正規表示式所定義的位置。正則表達式模式的搜尋會從輸入字串中的指定字元位置開始。
Split(String, String)	將輸入字串分割成正則表示式模式所定義位置的子字串陣列。
Split(String)	將輸入字串分割成子字串數位，該數位位於 Regex 建構函式中指定的正規表示式模式所定義的位置。
Split(String, Int32)	將指定的最大次數的輸入字串分割成子字串陣列，該陣列位於 Regex 建構函式中指定的正規表示式所定義的位置。

Split(String, String, RegexOptions, TimeSpan)

來源:: Regex.Split.cs

來源:: Regex.Split.cs

來源:: Regex.Split.cs

將輸入字串分割成指定正則表示式模式所定義位置的子字串陣列。其他參數會指定修改比對作業的選項，如果找不到相符專案，則會指定超時時間間隔。

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Split : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string[]

Public Shared Function Split (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As String()

參數

input: String

要分割的字串。

pattern: String

要比對的正則表達式模式。

options: RegexOptions

列舉值的位元組合，提供比對的選項。

matchTimeout: TimeSpan

超時時間間隔，或 InfiniteMatchTimeout，表示方法不應該逾時。

傳回

String[]

字串陣列。

例外狀況

ArgumentException

發生正則表達式剖析錯誤。

ArgumentNullException

input 或 patternnull。

ArgumentOutOfRangeException

options 不是 RegexOptions 值的有效位組合。

-或-

matchTimeout 為負數、零或大於大約 24 天。

RegexMatchTimeoutException

發生逾時。如需逾時的詳細資訊，請參閱一節。

備註

Regex.Split 方法類似於 String.Split(Char[]) 方法，不同之處在於 Regex.Split 在正則表達式所決定的分隔符分割字串，而不是一組字元。字串會盡可能分割多次。如果找不到分隔符，則傳回值會包含一個元素，其值為原始 input 字串。

pattern 參數是由正則表達式語言專案所組成，這些元素會以符號方式描述要比對的字串。如需正規表示式的詳細資訊，請參閱 .NET 正則表示式和正則表示式語言 - 快速參考。

重要

自動快取在呼叫靜態 Split 方法時所使用的已編譯正則表達式。若要自行管理已編譯正則表達式的存留期，請使用實例 Split 方法。

如果多個相符專案彼此相鄰，則會將空字串插入數位中。例如，在單一連字元上分割字串會導致傳回的陣列在找到兩個相鄰連字元的位置中包含空字串。

如果在輸入字串的開頭或結尾找到相符專案，則會在傳回陣列的開頭或結尾包含空字串。下列範例會使用正則表達式模式 [a-z]+ 在任何大寫或小寫字母字元上分割輸入字串。因為字串會以相符的字母字元開頭和結尾，因此傳回陣列的第一個和最後一個專案的值會 String.Empty。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "[a-z]+";
      string input = "Abc1234Def5678Ghi9012Jklm";
      string[] result = Regex.Split(input, pattern, 
                                    RegexOptions.IgnoreCase,
                                    TimeSpan.FromMilliseconds(500));
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', '1234', '5678', '9012', ''

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "[a-z]+"
      Dim input As String = "Abc1234Def5678Ghi9012Jklm"
      Dim result() As String = Regex.Split(input, pattern, 
                                           RegexOptions.IgnoreCase,
                                           TimeSpan.FromMilliseconds(500))
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', '1234', '5678', '9012', ''

如果在 Regex.Split 表示式中使用擷取括號，則產生的字串數位列會包含任何擷取的文字。例如，如果您在擷取括號內的連字元上分割字串「plum-pear」。，則傳回的數位會包含包含連字元的字串元素。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'

不過，當正則表示式模式包含多個擷取括弧時，此方法的行為取決於 .NET Framework 的版本。在 .NET Framework 1.0 和 1.1 中，如果在第一組擷取括弧內找不到相符專案，則從其他擷取括弧擷取的文字不會包含在傳回的數組中。從 .NET Framework 2.0 開始，所有擷取的文字也會新增至傳回的陣列。例如，下列程式代碼會使用兩組擷取括號，從日期字串擷取日期的專案，包括日期分隔符。第一組擷取括弧會擷取連字元，而第二組則會擷取正斜線。如果範例程式代碼是在 .NET Framework 1.0 或 1.1 下編譯並執行，則會排除斜線字元;如果編譯並執行於 .NET Framework 2.0 或更新版本下，則會包含它們。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

如果正則表示式可以符合空字串，Split 會將字串分割成單一字元字串陣列，因為可以在每個位置找到空字串分隔符。

matchTimeout 參數會指定模式比對方法在逾時之前應該嘗試尋找相符項目的時間長度。設定超時時間間隔可防止依賴過度回溯的正則表達式在處理包含接近相符項目的輸入時停止回應。如需詳細資訊，請參閱正則表示式的最佳做法和回溯。如果該時間間隔中找不到相符專案，此方法會擲回 RegexMatchTimeoutException 例外狀況。 matchTimeout 會覆寫針對方法執行的應用程式域所定義的任何預設逾時值。

給呼叫者的注意事項

我們建議您將 matchTimeout 參數設定為適當的值，例如兩秒。如果您藉由指定 InfiniteMatchTimeout來停用逾時，正則表達式引擎會提供稍微更好的效能。不過，您應該只在下列情況下停用逾時：

正則表達式所處理的輸入衍生自已知且受信任的來源，或包含靜態文字時。這會排除使用者動態輸入的文字。
當正則表達式模式經過徹底測試，以確保其有效率地處理相符專案、不相符專案和接近相符專案時。
當正則表達式模式不包含任何已知在處理接近相符專案時造成過度回溯的語言元素。

另請參閱

正則表示式語言專案

適用於

Split(String, String, RegexOptions)

來源:: Regex.Split.cs

來源:: Regex.Split.cs

來源:: Regex.Split.cs

將輸入字串分割成指定正則表示式模式所定義位置的子字串陣列。指定的選項會修改比對作業。

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);

static member Split : string * string * System.Text.RegularExpressions.RegexOptions -> string[]

Public Shared Function Split (input As String, pattern As String, options As RegexOptions) As String()

參數

input: String

要分割的字串。

pattern: String

要比對的正則表達式模式。

options: RegexOptions

列舉值的位元組合，提供比對的選項。

傳回

String[]

字串陣列。

例外狀況

ArgumentException

發生正則表達式剖析錯誤。

ArgumentNullException

input 或 patternnull。

ArgumentOutOfRangeException

options 不是 RegexOptions 值的有效位組合。

RegexMatchTimeoutException

發生逾時。如需逾時的詳細資訊，請參閱一節。

備註

重要

自動快取在呼叫靜態 Split 方法時所使用的已編譯正則表達式。若要自行管理已編譯正則表達式的存留期，請使用實例 Split 方法。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "[a-z]+";
      string input = "Abc1234Def5678Ghi9012Jklm";
      string[] result = Regex.Split(input, pattern, 
                                    RegexOptions.IgnoreCase);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', '1234', '5678', '9012', ''

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "[a-z]+"
      Dim input As String = "Abc1234Def5678Ghi9012Jklm"
      Dim result() As String = Regex.Split(input, pattern, 
                                           RegexOptions.IgnoreCase)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', '1234', '5678', '9012', ''

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

如果正則表示式可以符合空字串，Split 會將字串分割成單一字元字串陣列，因為可以在每個位置找到空字串分隔符。

如果分割作業的運行時間超過呼叫方法的應用程式域所指定的超時時間間隔，就會擲回 RegexMatchTimeoutException 例外狀況。如果在應用程式域的屬性中未定義逾時，或逾時值 Regex.InfiniteMatchTimeout，則不會擲回任何例外狀況。

給呼叫者的注意事項

這個方法會在間隔後逾時，這個間隔等於呼叫方法之應用程式域的預設逾時值。如果尚未為應用程式域定義逾時值，則會使用 InfiniteMatchTimeout值，以防止方法逾時。在模式比對上分割文字的建議靜態方法是 Split(String, String, RegexOptions, TimeSpan)，這可讓您設定超時時間間隔。

另請參閱

正則表示式語言專案

適用於

Split(String, Int32, Int32)

來源:: Regex.Split.cs

來源:: Regex.Split.cs

來源:: Regex.Split.cs

將指定的最大次數的輸入字串分割成子字串陣列，該陣列位於 Regex 建構函式中指定的正規表示式所定義的位置。正則表達式模式的搜尋會從輸入字串中的指定字元位置開始。

public:
 cli::array <System::String ^> ^ Split(System::String ^ input, int count, int startat);

public string[] Split (string input, int count, int startat);

member this.Split : string * int * int -> string[]

Public Function Split (input As String, count As Integer, startat As Integer) As String()

參數

input: String

要分割的字串。

count: Int32

分割可以發生的次數上限。

startat: Int32

輸入字串中開始搜尋的字元位置。

傳回

String[]

字串陣列。

例外狀況

ArgumentNullException

input null。

ArgumentOutOfRangeException

startat 小於零或大於 input長度。

RegexMatchTimeoutException

發生逾時。如需逾時的詳細資訊，請參閱一節。

備註

Regex.Split 方法類似於 String.Split 方法，不同之處在於 Regex.Split 在正則表達式所決定的分隔符分割字串，而不是一組字元。 count 參數會指定分割 input 字串的最大子字串數目;最後一個字串包含字串的 unsplit 餘數。零的 count 值會提供盡可能多地分割的默認行為。 startat 參數會定義第一個分隔符開始搜尋的點（這可用於略過前置空格符）。

如需 startat的詳細資訊，請參閱 Match(String, Int32)的一節。

如果字串中 count+1 位置找不到相符專案，此方法會傳回包含 input 字串的一個元素陣列。如果找到一或多個相符專案，則傳回陣列的第一個元素會包含字元串的第一個部分，從第一個字元到比對前一個字元。

如果多個相符專案彼此相鄰，而且找到的相符項目數目至少小於 count，則會將空字串插入陣列中。同樣地，如果在 startat找到相符專案，也就是字串中的第一個字元，則傳回陣列的第一個專案是空字串。也就是說，在判斷相符子字串數目是否等於 count時，會計算來自相鄰相符專案的空字串數目。在下列範例中，正則表達式 \d+ 用來尋找字串中第一個數值字元子字串的起始位置，然後從該位置開始最多三次分割字元串。由於正則表達式模式符合輸入字串的開頭，傳回的字串陣列包含空字串、五個字元的字母字串，以及字串串的其餘部分。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJ789KLMNO012PQRST";
      Match m = rgx.Match(input);
      if (m.Success) { 
         int startAt = m.Index;
         string[] result = rgx.Split(input, 3, startAt);
         for (int ctr = 0; ctr < result.Length; ctr++) {
            Console.Write("'{0}'", result[ctr]);
            if (ctr < result.Length - 1)
               Console.Write(", ");
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJ789KLMNO012PQRST"
      Dim m As Match = rgx.Match(input)
      If m.Success Then 
         Dim startAt As Integer = m.Index
         Dim result() As String = rgx.Split(input, 3, startAt)
         For ctr As Integer = 0 To result.Length - 1
            Console.Write("'{0}'", result(ctr))
            If ctr < result.Length - 1 Then Console.Write(", ")
         Next
         Console.WriteLine()
      End If
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

如果在正則表示式中使用擷取括號，則會在分割字串數位中包含任何擷取的文字。不過，任何包含擷取文字的陣列元素，都不會計算在判斷相符項目數目是否已達到 count。例如，將字串 '“apple-apricot-plum-pear-pomegranate-pineapple-peach” 分割成最多四個子字符串，從字符串中的字元 15 開始，會產生七個元素數位，如下列程式代碼所示。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)";
      string input = "apple-apricot-plum-pear-pomegranate-pineapple-peach";

      // Split on hyphens from 15th character on
      Regex regex = new Regex(pattern);    
      // Split on hyphens from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The method writes the following to the console:
//    'apple-apricot-plum'
//    '-'
//    'pear'
//    '-'
//    'pomegranate'
//    '-'
//    'pineapple-peach'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)"
      Dim input As String = "apple-apricot-plum-pear-pomegranate-pineapple-peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on hyphens from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub  
End Module
' The example displays the following output:
'    'apple-apricot-plum'
'    '-'
'    'pear'
'    '-'
'    'pomegranate'
'    '-'
'    'pineapple-peach'

不過，當正則表示式模式包含多個擷取括弧時，此方法的行為取決於 .NET Framework 的版本。在 .NET Framework 1.0 和 1.1 中，如果在第一組擷取括弧內找不到相符專案，則從其他擷取括弧擷取的文字不會包含在傳回的數組中。從 .NET Framework 2.0 開始，所有擷取的文字也會新增至傳回的陣列。例如，下列程式代碼會使用兩組擷取括號來擷取字串中的個別單字。第一組擷取括弧會擷取連字元，而第二組會擷取垂直線。如果範例程式代碼是在 .NET Framework 1.0 或 1.1 下編譯並執行，則會排除垂直橫條字元;如果編譯並執行於 .NET Framework 2.0 或更新版本下，則會包含它們。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)|([|])";     // possible delimiters found in string
      string input = "apple|apricot|plum|pear|pomegranate|pineapple|peach";

      Regex regex = new Regex(pattern);    
      // Split on delimiters from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// In .NET 2.0 and later, the method returns an array of
// 7 elements, as follows:
//    apple|apricot|plum'
//    '|'
//    'pear'
//    '|'
//    'pomegranate'
//    '|'
//    'pineapple|peach'
// In .NET 1.0 and 1.1, the method returns an array of
// 4 elements, as follows:
//    'apple|apricot|plum'
//    'pear'
//    'pomegranate'
//    'pineapple|peach'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)|([|])"   ' possible delimiters found in string
      Dim input As String = "apple|apricot|plum|pear|pomegranate|pineapple|peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on delimiters from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' In .NET 2.0, the method returns an array of
' 7 elements, as follows:
'    apple|apricot|plum'
'    '|'
'    'pear'
'    '|'
'    'pomegranate'
'    '|'
'    'pineapple|peach'
' In .NET 1.0 and 1.1, the method returns an array of
' 4 elements, as follows:
'    'apple|apricot|plum'
'    'pear'
'    'pomegranate'
'    'pineapple|peach'

如果正則表示式可以符合空字串，Split 會將字串分割成單一字元字串陣列，因為可以在每個位置找到空字串分隔符。下列範例會從字元「a」開始，將字串「characters」分割成輸入字串所包含的項目數目。因為 Null 字串符合輸入字串的結尾，因此會在傳回陣列的結尾插入 Null 字串。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      Regex regex = new Regex("");
      string[] substrings = regex.Split(input, input.Length, input.IndexOf("a"));
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write(substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example displays the following output:   
//    {, c, h, a, r, a, c, t, e, rs}

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input, input.Length, _
                                               input.IndexOf("a"))
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {, c, h, a, r, a, c, t, e, rs}

如果分割作業的運行時間超過 Regex.Regex(String, RegexOptions, TimeSpan) 建構函式指定的超時時間間隔，就會擲回 RegexMatchTimeoutException 例外狀況。如果您在呼叫建構函式時未設定超時時間間隔，則如果作業超過為建立 Regex 對象的應用程式域所建立的任何逾時值，則會擲回例外狀況。如果在 Regex 建構函式呼叫或應用程式域的屬性中未定義逾時，或逾時值 Regex.InfiniteMatchTimeout，則不會擲回任何例外狀況

另請參閱

正則表示式語言 - 快速參考

適用於

Split(String, String)

來源:: Regex.Split.cs

來源:: Regex.Split.cs

來源:: Regex.Split.cs

將輸入字串分割成正則表示式模式所定義位置的子字串陣列。

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern);

public static string[] Split (string input, string pattern);

static member Split : string * string -> string[]

Public Shared Function Split (input As String, pattern As String) As String()

參數

input: String

要分割的字串。

pattern: String

要比對的正則表達式模式。

傳回

String[]

字串陣列。

例外狀況

ArgumentException

發生正則表達式剖析錯誤。

ArgumentNullException

input 或 patternnull。

RegexMatchTimeoutException

發生逾時。如需逾時的詳細資訊，請參閱一節。

備註

Regex.Split 方法類似於 String.Split 方法，不同之處在於 Regex.Split 在正則表達式所決定的分隔符分割字串，而不是一組字元。 input 字串會盡可能分割多次。如果在 input 字串中找不到 pattern，則傳回值會包含一個值為原始 input 字串的專案。

重要

自動快取在呼叫靜態 Split 方法時所使用的已編譯正則表達式。若要自行管理已編譯正則表達式的存留期，請使用實例 Split 方法。

如果多個相符專案彼此相鄰，則會將空字串插入數位中。例如，在單一連字元上分割字串會導致傳回的數位列列在找到兩個相鄰連字元的位置中包含空字串，如下列程式碼所示。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum--pear";
      string pattern = "-";            // Split on hyphens
      
      string[] substrings = Regex.Split(input, pattern);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The method displays the following output:
//    'plum'
//    ''
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum--pear"
      Dim pattern As String = "-"          ' Split on hyphens
      
      Dim substrings() As String = Regex.Split(input, pattern)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub  
End Module
' The example displays the following output:
'    'plum'
'    ''
'    'pear'

如果在輸入字串的開頭或結尾找到相符專案，則會在傳回陣列的開頭或結尾包含空字串。下列範例會使用正則表達式模式 \d+ 來分割數值字元上的輸入字串。因為字串的開頭和結尾是相符的數值字元，因此傳回陣列的第一個和最後一個專案的值是 String.Empty。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      string[] result = Regex.Split(input, pattern);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      Dim result() As String = Regex.Split(input, pattern)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

如果正則表示式可以符合空字串，Split 會將字串分割成單一字元字串陣列，因為可以在每個位置找到空字串分隔符。例如：

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      string[] substrings = Regex.Split(input, "");
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write("'{0}'", substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example produces the following output:   
//    {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim substrings() As String = Regex.Split(input, "")
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write("'{0}'", substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}

請注意，傳回的陣列也會在數位的開頭和結尾包含空字串。

給呼叫者的注意事項

另請參閱

正則表示式語言專案

適用於

Split(String)

來源:: Regex.Split.cs

來源:: Regex.Split.cs

來源:: Regex.Split.cs

將輸入字串分割成子字串數位，該數位位於 Regex 建構函式中指定的正規表示式模式所定義的位置。

public:
 cli::array <System::String ^> ^ Split(System::String ^ input);

public string[] Split (string input);

member this.Split : string -> string[]

Public Function Split (input As String) As String()

參數

input: String

要分割的字串。

傳回

String[]

字串陣列。

例外狀況

ArgumentNullException

input null。

RegexMatchTimeoutException

發生逾時。如需逾時的詳細資訊，請參閱一節。

備註

Regex.Split 方法類似於 String.Split(Char[]) 方法，不同之處在於 Regex.Split 在正則表達式所決定的分隔符分割字串，而不是一組字元。字串會盡可能分割多次。如果找不到分隔符，傳回值會包含一個值為原始輸入字串的專案。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Regex regex = new Regex("-");         // Split on hyphens.
      string[] substrings = regex.Split("plum--pear");
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    ''
//    'pear'

Imports System.Text.RegularExpressions

Module RegexSplit
   Public Sub Main()
      Dim regex As Regex = New Regex("-")         ' Split on hyphens.
      Dim substrings() As String = regex.Split("plum--pear")
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'plum'
'    ''
'    'pear'

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      
      string[] result = rgx.Split(input);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      
      Dim result() As String = rgx.Split(input)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Regex regex = new Regex("(-)");         // Split on hyphens.
      string[] substrings = regex.Split("plum-pear");
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim regex As Regex = New Regex("(-)")          ' Split on hyphens.
      Dim substrings() As String = regex.Split("plum-pear")
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'plum'
'    '-'
'    'pear'

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

如果正則表示式可以符合空字串，Split(String) 會將字串分割成單一字元字串陣列，因為可以在每個位置找到空字串分隔符。例如：

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      Regex regex = new Regex("");
      string[] substrings = regex.Split(input);
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write(substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example displays the following output:   
//    {, c, h, a, r, a, c, t, e, r, s, }

Imports System.Text.RegularExpressions

Module Main
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input)
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {, c, h, a, r, a, c, t, e, r, s, }

請注意，傳回的陣列也會在數位的開頭和結尾包含空字串。

另請參閱

正則表示式語言 - 快速參考

適用於

Split(String, Int32)

來源:: Regex.Split.cs

來源:: Regex.Split.cs

來源:: Regex.Split.cs

將指定的最大次數的輸入字串分割成子字串陣列，該陣列位於 Regex 建構函式中指定的正規表示式所定義的位置。

public:
 cli::array <System::String ^> ^ Split(System::String ^ input, int count);

public string[] Split (string input, int count);

member this.Split : string * int -> string[]

Public Function Split (input As String, count As Integer) As String()

參數

input: String

要分割的字串。

count: Int32

分割可以發生的次數上限。

傳回

String[]

字串陣列。

例外狀況

ArgumentNullException

input null。

RegexMatchTimeoutException

發生逾時。如需逾時的詳細資訊，請參閱一節。

備註

Regex.Split 方法類似於 String.Split 方法，不同之處在於 Regex.Split 在正則表達式所決定的分隔符分割字串，而不是一組字元。 count 參數會指定要分割 input 字串的最大子字元串數目;最後一個字串包含字串的 unsplit 餘數。零的 count 值會提供盡可能多地分割的默認行為。

如果多個相符專案彼此相鄰，或在 input的開頭或結尾找到相符專案，而且找到的相符項目數目至少小於 count，則會將空字串插入數位中。也就是說，在判斷相符子字串數目是否等於 count時，會計算來自相鄰相符相符專案或輸入字元串開頭或結尾相符專案的空字串。在下列範例中，正則表達式 /d+ 用來將包含一或多個十進位數的輸入字串分割成最多三個子字串。由於輸入字串的開頭符合正則表達式模式，因此第一個陣列元素包含 String.Empty，第二個陣列元素包含輸入字串中的第一組字母字元，而第三個則包含第三個相符專案的其餘字元串。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      
      string[] result = rgx.Split(input, 3);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      
      Dim result() As String = rgx.Split(input, 3)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

如果在正則表示式中使用擷取括號，則會在分割字串數位中包含任何擷取的文字。不過，任何包含擷取文字的陣列元素，都不會計算在判斷相符項目數目是否已達到 count。例如，將字串串「apple-apricot-plum-pear-banana」分割成最多四個子字串會產生七個元素數位列，如下列程式代碼所示。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)";
      string input = "apple-apricot-plum-pear-banana";
      Regex regex = new Regex(pattern);         // Split on hyphens.
      string[] substrings = regex.Split(input, 4);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//       'apple'
//       '-'
//       'apricot'
//       '-'
//       'plum'
//       '-'
//       'pear-banana'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)"
      Dim input As String = "apple-apricot-plum-pear-banana"
      Dim regex As Regex = New Regex(pattern)         ' Split on hyphens.
      Dim substrings() As String = regex.Split(input, 4)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'apple'
'    '-'
'    'apricot'
'    '-'
'    'plum'
'    '-'
'    'pear-banana'

不過，當正則表示式模式包含多個擷取括弧時，此方法的行為取決於 .NET Framework 的版本。在 .NET Framework 1.0 和 1.1 中，只會在傳回的陣列中包含從第一組擷取括弧擷取的文字。從 .NET Framework 2.0 開始，所有擷取的文字都會新增至傳回的陣列。不過，在判斷相符子字串數目是否等於 count時，不會計算包含所擷取文字的傳回數位元素。例如，在下列程式代碼中，正則表達式會使用兩組擷取括號，從日期字串擷取日期的專案。第一組擷取括弧會擷取連字元，而第二組則會擷取正斜線。接著，呼叫 Split(String, Int32) 方法會指定傳回陣列中最多兩個專案。如果範例程式代碼是在 .NET Framework 1.0 或 1.1 下編譯並執行，則方法會傳回雙元素字串數位。如果編譯並執行於 .NET Framework 2.0 或更新版本下，此方法會傳回三個元素字串數位。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input, 2)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 2 elements, as follows:
//    '07'
//    '14/2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '/'
//    '14/2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input, 2) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 2 elements, as follows:
'    '07'
'    '14/2007'
'
' In .NET 2.0 and later, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '/'
'    '14/2007'

如果正則表示式可以符合空字串，Split(String, Int32) 會將字串分割成單一字元字串陣列，因為可以在每個位置找到空字串分隔符。下列範例會將字串「characters」分割成輸入字串中的元素數目。因為 Null 字串符合輸入字串的開頭，因此會在傳回陣列的開頭插入 Null 字串。這會導致第十個元素包含輸入字串結尾的兩個字元。

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input, input.Length)
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         if ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example displays the following output:   
'    {, c, h, a, r, a, c, t, e, rs}

另請參閱

正則表示式語言 - 快速參考

適用於

共用方式為

Regex.Split 方法

定義

多載

Split(String, String, RegexOptions, TimeSpan)

參數

傳回

例外狀況

備註

給呼叫者的注意事項

另請參閱

適用於

Split(String, String, RegexOptions)

參數

傳回

例外狀況

備註

給呼叫者的注意事項

另請參閱

適用於

Split(String, Int32, Int32)

參數

傳回

例外狀況

備註

另請參閱

適用於

Split(String, String)

參數

傳回

例外狀況

備註

給呼叫者的注意事項

另請參閱

適用於

Split(String)

參數

傳回

例外狀況

備註

另請參閱

適用於

Split(String, Int32)

參數

傳回

例外狀況

備註

另請參閱

適用於

意見反應

其他資源