Regex.Split Metoda

Definice

Rozdělí vstupní řetězec na pole podřetězce na pozicích definovaných regulárním výrazem.

Přetížení

Split(String)

Rozdělí vstupní řetězec na pole podřetězců na pozicích definovaných vzorem regulárního výrazu zadaným v konstruktoru Regex .

Split(String, Int32)

Rozdělí vstupní řetězec zadaný maximální početkrát do pole podřetězců na pozicích definovaných regulárním výrazem zadaným v konstruktoru Regex .

Split(String, String)

Rozdělí vstupní řetězec na pole podřetězců na pozicích definovaných vzorem regulárního výrazu.

Split(String, Int32, Int32)

Rozdělí vstupní řetězec zadaný maximální početkrát do pole podřetězců na pozicích definovaných regulárním výrazem zadaným v konstruktoru Regex . Hledání vzoru regulárního výrazu začíná na zadané pozici znaku ve vstupním řetězci.

Split(String, String, RegexOptions)

Rozdělí vstupní řetězec na pole podřetězců na pozicích definovaných zadaným vzorem regulárního výrazu. Zadané možnosti upraví odpovídající operaci.

Split(String, String, RegexOptions, TimeSpan)

Rozdělí vstupní řetězec na pole podřetězců na pozicích definovaných zadaným vzorem regulárního výrazu. Další parametry určují možnosti, které upravují odpovídající operaci a časový limit, pokud se nenajde žádná shoda.

Split(String)

Rozdělí vstupní řetězec na pole podřetězců na pozicích definovaných vzorem regulárního výrazu zadaným v konstruktoru 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()

Parametry

input
String

Řetězec, který se má rozdělit.

Návraty

String[]

Pole řetězců.

Výjimky

input je null.

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Poznámky

Metody Regex.Split jsou podobné String.Split(Char[]) metodě s tím rozdílem, že Regex.Split rozdělí řetězec na oddělovač určený regulárním výrazem místo sady znaků. Řetězec se rozdělí tolikrát, kolikrát je to možné. Pokud není nalezen žádný oddělovač, návratová hodnota obsahuje jeden prvek, jehož hodnota je původní vstupní řetězec.

Pokud je více shod vzájemně sousedících, vloží se do pole prázdný řetězec. Například rozdělení řetězce na jeden spojovník způsobí, že vrácené pole bude obsahovat prázdný řetězec na pozici, kde jsou nalezeny dva sousední spojovníky, jak ukazuje následující kód.

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'

Pokud je nalezena shoda na začátku nebo na konci vstupního řetězce, je na začátku nebo konci vráceného pole zahrnut prázdný řetězec. Následující příklad používá vzor \d+ regulárního výrazu k rozdělení vstupního řetězce na číselné znaky. Protože řetězec začíná a končí odpovídajícími číselnými znaky, hodnota prvního a posledního prvku vráceného pole je 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);
      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', ''

Pokud se ve Regex.Split výrazu použijí zachytávané závorky, zahrne se do výsledného pole řetězců jakýkoli zachycený text. Pokud například rozdělíte řetězec "plum-pear" na spojovník umístěný v zachytávání závorek, vrácené pole obsahuje prvek řetězce, který obsahuje spojovník.

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'

Pokud však vzor regulárního výrazu zahrnuje více sad zachycení závorek, chování této metody závisí na verzi rozhraní .NET Framework. V rozhraní .NET Framework 1.0 a 1.1 není-li nalezena shoda v první sadě zachycení závorek, zachycený text z dalších zachytávání závorek není zahrnut do vráceného pole. Počínaje rozhraním .NET Framework 2.0 se veškerý zachycený text přidá také do vráceného pole. Například následující kód používá dvě sady zachycení závorek k extrahování prvků data, včetně oddělovačů data, z řetězce data. První sada zachycení závorek zachytává spojovník a druhá sada zachycuje lomítko. Pokud je příklad kódu zkompilován a spuštěn pod rozhraním .NET Framework 1.0 nebo 1.1, vylučuje znaky lomítka; pokud je zkompilován a spuštěn v rámci rozhraní .NET Framework 2.0 nebo novější verze, zahrnuje je.

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'

Pokud se regulární výraz může shodovat s prázdným řetězcem, Split(String) rozdělí řetězec na pole jednoznakových řetězců, protože oddělovač prázdných řetězců lze nalézt na každém místě. Příklad:

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, }

Všimněte si, že vrácené pole obsahuje také prázdný řetězec na začátku a konci pole.

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění operace rozdělení překročí interval časového limitu určeného konstruktorem Regex.Regex(String, RegexOptions, TimeSpan) . Pokud nenastavíte interval časového limitu při volání konstruktoru, je vyvolána výjimka, pokud operace překročí hodnotu časového limitu stanovenou pro doménu aplikace, ve které Regex je objekt vytvořen. Pokud není ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.

Viz také

Platí pro

Split(String, Int32)

Rozdělí vstupní řetězec zadaný maximální početkrát do pole podřetězců na pozicích definovaných regulárním výrazem zadaným v konstruktoru 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()

Parametry

input
String

Řetězec, který se má rozdělit.

count
Int32

Maximální počet výskytů rozdělení

Návraty

String[]

Pole řetězců.

Výjimky

input je null.

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Poznámky

Metody Regex.Split jsou podobné String.Split metodě s tím rozdílem, že Regex.Split rozdělí řetězec na oddělovač určený regulárním výrazem místo sady znaků. Parametr count určuje maximální počet podřetězců, do kterých input lze řetězec rozdělit; poslední řetězec obsahuje nerozsvícený zbytek řetězce. count Hodnota nula poskytuje výchozí chování dělení co nejvícekrát.

Pokud spolu sousedí více shod nebo pokud je nalezena shoda na začátku nebo na konci inputa počet nalezených shod je alespoň o dvě menší než count, vloží se do pole prázdný řetězec. To znamená, že prázdné řetězce, které jsou výsledkem sousedních shod nebo ze shod na začátku nebo konci vstupního řetězce, se počítají při určování, jestli se počet odpovídajících podřetězců rovná count. V následujícím příkladu se regulární výraz /d+ používá k rozdělení vstupního řetězce, který obsahuje jednu nebo více desetinných číslic, do maximálně tří podřetězců. Protože začátek vstupního řetězce odpovídá vzoru regulárního výrazu, první prvek pole obsahuje String.Empty, druhý obsahuje první sadu abecedních znaků ve vstupním řetězci a třetí obsahuje zbytek řetězce, který následuje po třetí shodě.

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'

Pokud jsou zachycené závorky použity v regulárním výrazu, je jakýkoli zachycený text zahrnut do pole rozdělených řetězců. Žádné prvky pole, které obsahují zachycený text, se však nezapočítávají do určení, zda počet shod dosáhl count. Například rozdělení řetězce "jablko-meruňka-plum-hruška-banán" na maximálně čtyři podřetězce způsobí sedmiprvkové pole, jak ukazuje následující kód.

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'

Pokud však vzor regulárního výrazu zahrnuje více sad zachycení závorek, chování této metody závisí na verzi rozhraní .NET Framework. V rozhraní .NET Framework 1.0 a 1.1 je do vráceného pole zahrnut pouze zachycený text z první sady zachycených závorek. Počínaje rozhraním .NET Framework 2.0 se veškerý zachycený text přidá do vráceného pole. Prvky ve vráceném poli, které obsahují zachycený text, se však nezapočítávají při určování, zda se počet odpovídajících podřetěžců rovná count. Například v následujícím kódu regulární výraz používá dvě sady zachycení závorek k extrahování prvků data z řetězce kalendářního data. První sada zachycení závorek zachytává spojovník a druhá sada zachycuje lomítko. Volání Split(String, Int32) metody pak určuje maximálně dva prvky ve vrácených polích. Pokud je ukázkový kód zkompilován a spuštěn v rozhraní .NET Framework 1.0 nebo 1.1, vrátí metoda pole řetězců se dvěma prvky. Pokud je zkompilován a spuštěn v rámci rozhraní .NET Framework 2.0 nebo novější verze, vrátí metoda pole řetězců se třemi prvky.

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'

Pokud se regulární výraz může shodovat s prázdným řetězcem, Split(String, Int32) rozdělí řetězec na pole jednoznakových řetězců, protože oddělovač prázdných řetězců lze nalézt na každém místě. Následující příklad rozdělí řetězec "znaků" na tolik prvků, kolik je ve vstupním řetězci. Vzhledem k tomu, že řetězec null odpovídá začátku vstupního řetězce, řetězec null se vloží na začátek vráceného pole. To způsobí, že desátý prvek se skládá ze dvou znaků na konci vstupního řetězce.

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}

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění operace rozdělení překročí interval časového limitu určeného konstruktorem Regex.Regex(String, RegexOptions, TimeSpan) . Pokud nenastavíte interval časového limitu při volání konstruktoru, je vyvolána výjimka, pokud operace překročí hodnotu časového limitu stanovenou pro doménu aplikace, ve které Regex je objekt vytvořen. Pokud není ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.

Viz také

Platí pro

Split(String, String)

Rozdělí vstupní řetězec na pole podřetězců na pozicích definovaných vzorem regulárního výrazu.

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()

Parametry

input
String

Řetězec, který se má rozdělit.

pattern
String

Vzor regulárního výrazu, který se má shodovat.

Návraty

String[]

Pole řetězců.

Výjimky

Při analýze regulárního výrazu došlo k chybě.

input nebo pattern je null.

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Poznámky

Metody Regex.Split jsou podobné String.Split metodě s tím rozdílem, že Regex.Split rozdělí řetězec na oddělovač určený regulárním výrazem místo sady znaků. Řetězec input se rozdělí tolikrát, kolikrát je to možné. Pokud pattern se v řetězci input nenajde, bude vrácená hodnota obsahovat jeden prvek, jehož hodnota je původní input řetězec.

Parametr pattern se skládá z elementů jazyka regulárních výrazů, které symbolicky popisují řetězec, který se má shodovat. Další informace o regulárních výrazech najdete v tématu Regulární výrazy .NET a jazyk regulárních výrazů – stručné referenční informace.

Důležité

Kompilované regulární výrazy používané ve volání statických Split metod se automaticky ukládají do mezipaměti. Pokud chcete spravovat životnost kompilovaných regulárních výrazů sami, použijte metody instance Split .

Pokud je více shod vzájemně sousedících, vloží se do pole prázdný řetězec. Například rozdělení řetězce na jeden spojovník způsobí, že vrácené pole bude obsahovat prázdný řetězec na pozici, kde jsou nalezeny dva sousední spojovníky, jak ukazuje následující kód.

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'

Pokud je nalezena shoda na začátku nebo na konci vstupního řetězce, je na začátku nebo konci vráceného pole zahrnut prázdný řetězec. Následující příklad používá vzor \d+ regulárního výrazu k rozdělení vstupního řetězce na číselné znaky. Protože řetězec začíná a končí odpovídajícími číselnými znaky, hodnota prvního a posledního prvku vráceného pole je 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', ''

Pokud se ve Regex.Split výrazu použijí zachytávané závorky, zahrne se do výsledného pole řetězců jakýkoli zachycený text. Pokud například rozdělíte řetězec "plum-pear" na spojovník umístěný v zachytávání závorek, vrácené pole obsahuje prvek řetězce, který obsahuje spojovník.

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'

Pokud však vzor regulárního výrazu zahrnuje více sad zachycení závorek, chování této metody závisí na verzi rozhraní .NET Framework. V rozhraní .NET Framework 1.0 a 1.1 není-li nalezena shoda v první sadě zachycení závorek, zachycený text z dalších zachytávání závorek není zahrnut do vráceného pole. Počínaje rozhraním .NET Framework 2.0 se veškerý zachycený text přidá také do vráceného pole. Například následující kód používá dvě sady zachycení závorek k extrahování prvků data, včetně oddělovačů data, z řetězce data. První sada zachycení závorek zachytává spojovník a druhá sada zachycuje lomítko. Pokud je příklad kódu zkompilován a spuštěn pod rozhraním .NET Framework 1.0 nebo 1.1, vylučuje znaky lomítka; pokud je zkompilován a spuštěn v rámci rozhraní .NET Framework 2.0 nebo novější verze, zahrnuje je.

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'

Pokud se regulární výraz může shodovat s prázdným řetězcem, Split rozdělí řetězec na pole jednoznakových řetězců, protože oddělovač prázdných řetězců lze nalézt na každém místě. Příklad:

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', ''}

Všimněte si, že vrácené pole obsahuje také prázdný řetězec na začátku a konci pole.

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění operace rozdělení překročí interval časového limitu zadaného pro doménu aplikace, ve které je volána metoda. Pokud není ve vlastnostech domény aplikace definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.

Poznámky pro volající

Tato metoda vyprší časový limit po intervalu, který se rovná výchozí hodnotě časového limitu domény aplikace, ve které je volána metoda. Pokud pro doménu aplikace nebyla definována hodnota časového limitu, použije se hodnota InfiniteMatchTimeout, která brání vypršení časového limitu metody. Doporučenou statickou metodou pro rozdělení textu podle shody vzoru je Split(String, String, RegexOptions, TimeSpan), která umožňuje nastavit interval časového limitu.

Viz také

Platí pro

Split(String, Int32, Int32)

Rozdělí vstupní řetězec zadaný maximální početkrát do pole podřetězců na pozicích definovaných regulárním výrazem zadaným v konstruktoru Regex . Hledání vzoru regulárního výrazu začíná na zadané pozici znaku ve vstupním řetězci.

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()

Parametry

input
String

Řetězec, který se má rozdělit.

count
Int32

Maximální počet výskytů rozdělení

startat
Int32

Pozice znaku ve vstupním řetězci, kde začne hledání.

Návraty

String[]

Pole řetězců.

Výjimky

input je null.

startatje menší než nula nebo větší než délka .input

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Poznámky

Metody Regex.Split jsou podobné String.Split metodě s tím rozdílem, že Regex.Split rozdělí řetězec na oddělovač určený regulárním výrazem místo sady znaků. Parametr count určuje maximální počet podřetězců, do kterých input je řetězec rozdělen; poslední řetězec obsahuje nerozsvícený zbytek řetězce. count Hodnota nula poskytuje výchozí chování dělení co nejvícekrát. Parametr startat definuje bod, ve kterém začíná hledání prvního oddělovače (můžete ho použít pro přeskočení počátečních prázdných znaků).

Další podrobnosti o startatnástroji najdete v části Poznámky v souboru Match(String, Int32).

Pokud nejsou nalezeny žádné shody z countpozice +1 v řetězci, vrátí metoda pole s jedním prvkem, které obsahuje input řetězec. Pokud se najde jedna nebo více shod, první prvek vráceného pole obsahuje první část řetězce od prvního znaku až po jeden znak před shodou.

Pokud je více shod vzájemně sousedících a počet nalezených shod je alespoň o dvě menší než count, vloží se do pole prázdný řetězec. Podobně platí, že pokud je nalezena shoda na startatadrese , což je první znak v řetězci, je prvním prvkem vráceného pole prázdný řetězec. To znamená, že prázdné řetězce, které jsou výsledkem sousedních shod, se počítají při určování, jestli se počet odpovídajících podřetězců rovná count. V následujícím příkladu se regulární výraz \d+ používá k vyhledání počáteční pozice prvního podřetězce číselných znaků v řetězci a k rozdělení řetězce maximálně třikrát od této pozice. Vzhledem k tomu, že vzor regulárního výrazu odpovídá začátku vstupního řetězce, vrácené pole řetězců se skládá z prázdného řetězce, pětimístného abecedního řetězce a zbytku řetězce.

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'

Pokud jsou zachycené závorky použity v regulárním výrazu, je jakýkoli zachycený text zahrnut do pole rozdělených řetězců. Žádné prvky pole, které obsahují zachycený text, se však nezapočítávají do určení, zda počet shod dosáhl count. Například rozdělení řetězce ""jablko-meruňková-plum-hruška-granátové jablko-ananas-broskve" na maximálně čtyři podřetězce začínající znakem 15 v řetězci způsobí sedmiprvkové pole, jak ukazuje následující kód.

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'

Pokud však vzor regulárního výrazu zahrnuje více sad zachycení závorek, chování této metody závisí na verzi rozhraní .NET Framework. Pokud v rozhraní .NET Framework 1.0 a 1.1 není nalezena shoda v první sadě zachycených závorek, zachycený text z dalších zachytávejte závorky není zahrnut do vráceného pole. Počínaje rozhraním .NET Framework 2.0 se veškerý zachycený text přidá také do vráceného pole. Například následující kód používá dvě sady zachycení závorek k extrahování jednotlivých slov v řetězci. První sada zachycení závorek zachytává spojovník a druhá sada zachycuje svislý pruh. Pokud je příklad kódu zkompilován a spuštěn pod rozhraním .NET Framework 1.0 nebo 1.1, vylučuje svislé pruhové znaky; pokud je zkompilován a spuštěn v rámci rozhraní .NET Framework 2.0 nebo novější verze, zahrnuje je.

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'

Pokud se regulární výraz může shodovat s prázdným řetězcem, Split rozdělí řetězec na pole jednoznakových řetězců, protože oddělovač prázdných řetězců lze nalézt na každém místě. Následující příklad rozdělí řetězec "characters" na tolik prvků, kolik vstupní řetězec obsahuje, počínaje znakem "a". Vzhledem k tomu, že řetězec null odpovídá konci vstupního řetězce, řetězec null se vloží na konec vráceného pole.

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}

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění operace rozdělení překročí interval časového limitu určeného konstruktorem Regex.Regex(String, RegexOptions, TimeSpan) . Pokud nenastavíte interval časového limitu při volání konstruktoru, je vyvolána výjimka, pokud operace překročí hodnotu časového limitu stanovenou pro doménu aplikace, ve které Regex je objekt vytvořen. Pokud není ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.

Viz také

Platí pro

Split(String, String, RegexOptions)

Rozdělí vstupní řetězec na pole podřetězců na pozicích definovaných zadaným vzorem regulárního výrazu. Zadané možnosti upraví odpovídající operaci.

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()

Parametry

input
String

Řetězec, který se má rozdělit.

pattern
String

Vzor regulárního výrazu, který se má shodovat.

options
RegexOptions

Bitové kombinace hodnot výčtu, které poskytují možnosti pro porovnávání.

Návraty

String[]

Pole řetězců.

Výjimky

Při analýze regulárního výrazu došlo k chybě.

input nebo pattern je null.

options není platná bitové kombinace RegexOptions hodnot.

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Poznámky

Metody Regex.Split jsou podobné String.Split(Char[]) metodě s tím rozdílem, že Regex.Split rozdělí řetězec na oddělovač určený regulárním výrazem místo sady znaků. Řetězec se rozdělí tolikrát, kolikrát je to možné. Pokud není nalezen žádný oddělovač, návratová hodnota obsahuje jeden prvek, jehož hodnota je původní input řetězec.

Parametr pattern se skládá z elementů jazyka regulárních výrazů, které symbolicky popisují řetězec, který se má shodovat. Další informace o regulárních výrazech najdete v tématu Regulární výrazy .NET a jazyk regulárních výrazů – stručné referenční informace.

Důležité

Kompilované regulární výrazy používané ve volání statických Split metod se automaticky ukládají do mezipaměti. Pokud chcete spravovat životnost kompilovaných regulárních výrazů sami, použijte metody instance Split .

Pokud je více shod vzájemně sousedících, vloží se do pole prázdný řetězec. Například rozdělení řetězce na jeden spojovník způsobí, že vrácené pole bude obsahovat prázdný řetězec na pozici, kde jsou nalezeny dva sousední spojovníky.

Pokud je nalezena shoda na začátku nebo na konci vstupního řetězce, je na začátku nebo konci vráceného pole zahrnut prázdný řetězec. Následující příklad používá vzor [a-z]+ regulárního výrazu k rozdělení vstupního řetězce na libovolný znak abecedy s velkými nebo malými písmeny. Vzhledem k tomu, že řetězec začíná a končí odpovídajícími abecední znaky, hodnota prvního a posledního prvku vráceného pole je 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);
      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', ''

Pokud se ve Regex.Split výrazu použijí zachytávané závorky, zahrne se do výsledného pole řetězců jakýkoli zachycený text. Pokud například rozdělíte řetězec "plum-pear" na spojovník umístěný v zachytávání závorek, vrácené pole obsahuje prvek řetězce, který obsahuje spojovník.

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'

Pokud však vzor regulárního výrazu zahrnuje více sad zachycení závorek, chování této metody závisí na verzi rozhraní .NET Framework. V rozhraní .NET Framework 1.0 a 1.1 není-li nalezena shoda v první sadě zachycení závorek, zachycený text z dalších zachytávání závorek není zahrnut do vráceného pole. Počínaje rozhraním .NET Framework 2.0 se veškerý zachycený text přidá také do vráceného pole. Například následující kód používá dvě sady zachycení závorek k extrahování prvků data, včetně oddělovačů data, z řetězce data. První sada zachycení závorek zachytává spojovník a druhá sada zachycuje lomítko. Pokud je příklad kódu zkompilován a spuštěn pod rozhraním .NET Framework 1.0 nebo 1.1, vylučuje znaky lomítka; pokud je zkompilován a spuštěn v rámci rozhraní .NET Framework 2.0 nebo novější verze, zahrnuje je.

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'

Pokud se regulární výraz může shodovat s prázdným řetězcem, Split rozdělí řetězec na pole jednoznakových řetězců, protože oddělovač prázdných řetězců lze nalézt na každém místě.

Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění operace rozdělení překročí interval časového limitu zadaného pro doménu aplikace, ve které je volána metoda. Pokud není ve vlastnostech domény aplikace definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.

Poznámky pro volající

Tato metoda vyprší časový limit po intervalu, který se rovná výchozí hodnotě časového limitu domény aplikace, ve které je volána metoda. Pokud pro doménu aplikace nebyla definována hodnota časového limitu, použije se hodnota InfiniteMatchTimeout, která brání vypršení časového limitu metody. Doporučenou statickou metodou pro rozdělení textu podle shody vzoru je Split(String, String, RegexOptions, TimeSpan), která umožňuje nastavit interval časového limitu.

Viz také

Platí pro

Split(String, String, RegexOptions, TimeSpan)

Rozdělí vstupní řetězec na pole podřetězce na pozicích definovaných zadaným vzorem regulárního výrazu. Další parametry určují možnosti, které upraví operaci párování, a interval časového limitu, pokud není nalezena žádná shoda.

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()

Parametry

input
String

Řetězec, který chcete rozdělit.

pattern
String

Vzor regulárního výrazu, který se má shodovat.

options
RegexOptions

Bitové kombinace hodnot výčtu, které poskytují možnosti pro porovnávání.

matchTimeout
TimeSpan

Interval časového limitu nebo InfiniteMatchTimeout označující, že by nemělo dojít k vypršení časového limitu metody.

Návraty

String[]

Pole řetězců.

Výjimky

Došlo k chybě parsování regulárního výrazu.

input nebo pattern je null.

options není platná bitové kombinace RegexOptions hodnot.

-nebo-

matchTimeout je záporná, nulová nebo větší než přibližně 24 dnů.

Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.

Poznámky

Metody Regex.Split jsou podobné String.Split(Char[]) metodě s tím rozdílem, že Regex.Split rozdělí řetězec na oddělovač určený regulárním výrazem místo sady znaků. Řetězec se rozdělí tolikrát, kolikrát je to možné. Pokud není nalezen žádný oddělovač, návratová hodnota obsahuje jeden prvek, jehož hodnota je původní input řetězec.

Parametr pattern se skládá z elementů jazyka regulárních výrazů, které symbolicky popisují řetězec, který se má shodovat. Další informace o regulárních výrazech najdete v tématu Regulární výrazy .NET a Jazyk regulárních výrazů – stručná referenční příručka.

Důležité

Kompilované regulární výrazy používané při volání statických Split metod se automaticky ukládají do mezipaměti. Pokud chcete spravovat životnost zkompilovaných regulárních výrazů sami, použijte metody instance Split .

Pokud k sobě přiléhá více shod, vloží se do pole prázdný řetězec. Například rozdělení řetězce na jeden spojovník způsobí, že vrácené pole bude obsahovat prázdný řetězec na pozici, kde jsou nalezeny dvě sousední spojovníky.

Pokud je nalezena shoda na začátku nebo na konci vstupního řetězce, je na začátku nebo na konci vráceného pole zahrnut prázdný řetězec. Následující příklad používá vzor [a-z]+ regulárního výrazu k rozdělení vstupního řetězce na libovolný znak abecedy s velkými nebo malými písmeny. Vzhledem k tomu, že řetězec začíná a končí odpovídajícími abecední znaky, hodnota prvního a posledního prvku vráceného pole je 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', ''

Pokud jsou ve výrazu Regex.Split použity zachytávané závorky, je do výsledného pole řetězců zahrnut jakýkoli zachycený text. Pokud například rozdělíte řetězec "plum-pear" na spojovníku umístěném v zachytávání závorek, vrácené pole obsahuje prvek řetězce, který obsahuje spojovník.

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'

Pokud však vzor regulárního výrazu obsahuje více sad zachycení závorek, chování této metody závisí na verzi rozhraní .NET Framework. V rozhraní .NET Framework 1.0 a 1.1 není-li nalezena shoda v první sadě zachytávání závorek, zachycený text z dalších zachytávání závorek není zahrnut do vrácené pole. Počínaje rozhraním .NET Framework 2.0 se do vráceného pole přidá také veškerý zachycený text. Následující kód například používá dvě sady zachycení závorek k extrahování prvků data, včetně oddělovačů data, z řetězce kalendářního data. První sada zachycení závorek zachytí spojovník a druhá sada zachytí lomítko. Pokud je příklad kódu kompilován a spuštěn v rozhraní .NET Framework 1.0 nebo 1.1, vyloučí znaky lomítka; pokud je zkompilován a spuštěn v rozhraní .NET Framework 2.0 nebo novějších verzích, zahrnuje je.

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'

Pokud se regulární výraz může shodovat s prázdným řetězcem, Split rozdělí řetězec na pole jednoznačných řetězců, protože prázdný oddělovač řetězců lze najít na každém místě.

Parametr matchTimeout určuje, jak dlouho by se metoda porovnávání vzorů měla pokusit najít shodu, než vyprší časový limit. Nastavení intervalu časového limitu zabrání tomu, aby regulární výrazy, které jsou závislé na nadměrném navracení, přestaly reagovat, když zpracovávají vstup, který obsahuje téměř shody. Další informace najdete v tématu Osvědčené postupy pro regulární výrazy a backtracking. Pokud se v daném časovém intervalu nenajde žádná shoda, metoda vyvolá RegexMatchTimeoutException výjimku. matchTimeout přepíše všechny výchozí hodnoty časového limitu definované pro doménu aplikace, ve které se metoda spouští.

Poznámky pro volající

Doporučujeme nastavit matchTimeout parametr na odpovídající hodnotu, například dvě sekundy. Pokud zakážete vypršení časových limitů zadáním InfiniteMatchTimeout, modul regulárních výrazů nabízí o něco lepší výkon. Vypršení časových limitů byste ale měli zakázat pouze za následujících podmínek:

  • Když je vstup zpracovaný regulárním výrazem odvozen ze známého a důvěryhodného zdroje nebo se skládá ze statického textu. Tím se vyloučí text, který uživatelé zadává dynamicky.

  • Když byl vzor regulárního výrazu důkladně otestován, aby se zajistilo, že efektivně zpracovává shody, neshody a blízké shody.

  • Když vzor regulárního výrazu neobsahuje žádné elementy jazyka, o kterých je známo, že způsobují nadměrné navracení při zpracování téměř shody.

Viz také

Platí pro