Regex.Split Metoda

Definice

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

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 zadanou maximální dobu 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 zadanou maximální dobu 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 upravují 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 interval časového limitu, pokud nebyla nalezena žá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ý chcete 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 se nenajde žádný oddělovač, návratová hodnota obsahuje jeden prvek, jehož hodnota je původní vstupní řetězec.

Pokud několik shod spolu sousedí, vloží se do pole prázdný řetězec. Například rozdělení řetězce na jeden spojovník způsobí, že vrácená matice bude obsahovat prázdný řetězec na pozici, kde jsou nalezeny dvě 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 se najde shoda na začátku nebo na konci vstupního řetězce, je prázdný řetězec zahrnutý na začátku nebo na konci vráceného pole. 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 výrazu Regex.Split používají zachytávání závorek, 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átí pole 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 ale vzor regulárního výrazu zahrnuje více sad zachytávání závorek, chování této metody závisí na verzi rozhraní .NET Framework. Pokud se v rozhraní .NET Framework 1.0 a 1.1 nenajde shoda v první sadě zachytávání závorek, zachycený text z dalších zachytávání závorek není součástí vráceného 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 zachytávání závorek k extrakci prvků data, včetně oddělovačů kalendářních dat, z řetězce kalendářního data. První sada zachytávání závorek zachycuje spojovník a druhá sada zachycuje lomítko. Pokud je ukázkový kód zkompilován a spuštěn v rozhraní .NET Framework 1.0 nebo 1.1, vyloučí znaky lomítka; pokud je zkompilovaný 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 = @"(-)|(/)";
      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 regulární výraz odpovídá prázdnému řetězci, rozdělí řetězec na pole řetězců s jedním znakem, Split(String) protože prázdný oddělovač řetězců lze najít v každém umístění. 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á matice obsahuje také prázdný řetězec na začátku a na konci pole.

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

Viz také

Platí pro

Split(String, Int32)

Rozdělí vstupní řetězec zadanou maximální dobu 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 výjimkou toho, ž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 nesvícený zbytek řetězce. count Hodnota nuly poskytuje výchozí chování rozdělení co nejvícekrát.

Pokud je několik shod vedle sebe nebo pokud je nalezena shoda na začátku nebo na konci inputa počet nalezených shod je alespoň dva menší než count, vloží se do pole prázdný řetězec. To znamená, že prázdné řetězce, které mají za následek sousední shody nebo shody na začátku nebo konci vstupního řetězce, se počítají při určování, zda 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ů. Vzhledem k tomu, že začátek vstupního řetězce odpovídá vzoru regulárního výrazu, první prvek pole obsahuje , druhý obsahuje String.Emptyprvní sadu abecedních znaků ve vstupním řetězci a třetí obsahuje zbytek řetězce, který následuje za třetí shodu.

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 se v regulárním výrazu používají zachytávání závorek, je veškerý zachycený text součástí pole rozdělených řetězců. Všechny prvky pole, které obsahují zachycený text, se však nezapočítávají při určování, zda bylo dosaženo countpočtu shod . Například rozdělení řetězce "jablko-meruňka-plum-pear-banán" na maximálně čtyři podřetězce vede k matici sedmi prvků, 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 ale vzor regulárního výrazu zahrnuje více sad zachytávání 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 zachytávání závorek. Počínaje rozhraním .NET Framework 2.0 se do vráceného pole přidá veškerý zachycený text. Prvky v vrácené matici, 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ěžků rovná count. Například v následujícím kódu regulární výraz používá dvě sady zachytávání závorek k extrahování prvků data z řetězce kalendářního data. První sada zachytávání závorek zachycuje spojovník a druhá sada zachycuje lomítko. Volání Split(String, Int32) metody pak určuje maximálně dva prvky v vrácené matici. Pokud je ukázkový kód zkompilován a spuštěn pod rozhraním .NET Framework 1.0 nebo 1.1, vrátí metoda dvojúrovňové řetězcové pole. Pokud se zkompiluje a spustí v rozhraní .NET Framework 2.0 nebo novějších verzích, vrátí metoda pole řetězce se třemi elementy.

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 regulární výraz odpovídá prázdnému řetězci, rozdělí řetězec na pole řetězců s jedním znakem, Split(String, Int32) protože prázdný oddělovač řetězců lze najít v každém umístění. Následující příklad rozdělí řetězec "znaky" 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, je řetězec null vložen na začátek vráceného pole. To způsobí, že se desátý prvek bude skládat 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 se vyvolá, pokud doba provádění operace rozdělení překročí časový limit určený konstruktorem Regex.Regex(String, RegexOptions, TimeSpan) . Pokud při volání konstruktoru nenastavíte časový limit, vyvolá se výjimka, pokud operace překročí libovolnou hodnotu časového limitu vytvořenou pro doménu aplikace, ve které Regex je objekt vytvořen. Pokud není definován časový limit ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , není vyvolána žá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ý chcete rozdělit.

pattern
String

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

Návraty

String[]

Pole řetězců.

Výjimky

Došlo k chybě analýzy regulárních výrazů.

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 výjimkou toho, ž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í co nejvícekrát. Pokud pattern není v řetězci input nalezena, 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íchvýrazch

Důležité

Kompilované regulární výrazy používané ve voláních statických Split metod se automaticky ukládají do mezipaměti. Ke správě životnosti kompilovaných regulárních výrazů použijte metody instance Split .

Pokud je několik shod vedle sebe, vloží se do pole prázdný řetězec. Například rozdělení řetězce na jednom spojovníku způsobí, že vrácená pole bude obsahovat prázdný řetězec do pozice, kde jsou nalezeny dvě sousední pomlč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 prázdný řetězec zahrnut na začátku nebo na konci vráceného pole. 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 výrazu Regex.Split používají zachytávání závorek, zahrne se do výsledného pole řetězců veškerý 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átí pole obsahuje řetězcový prvek, 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 ale vzor regulárního výrazu zahrnuje více sad zachytávání závorek, chování této metody závisí na verzi rozhraní .NET Framework. Pokud se v rozhraní .NET Framework 1.0 a 1.1 nenajde shoda v první sadě zachytávání závorek, zachycený text z dalších zachytávání závorek není součástí vráceného 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 zachytávání závorek k extrakci prvků data, včetně oddělovačů kalendářních dat, z řetězce kalendářního data. První sada zachytávání závorek zachycuje spojovník a druhá sada zachycuje lomítko. Pokud je ukázkový kód zkompilován a spuštěn v rozhraní .NET Framework 1.0 nebo 1.1, vyloučí znaky lomítka; pokud je zkompilovaný 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 regulární výraz odpovídá prázdnému řetězci, rozdělí řetězec na pole řetězců s jedním znakem, Split protože prázdný oddělovač řetězců lze najít v každém umístění. 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á matice obsahuje také prázdný řetězec na začátku a na konci pole.

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

Poznámky pro volající

Tato metoda vyprší po intervalu, který se rovná výchozí hodnotě časového limitu domény aplikace, ve které se metoda volá. 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čená statická metoda rozdělení textu na shodu vzorku je Split(String, String, RegexOptions, TimeSpan), která umožňuje nastavit časový limit.

Viz také

Platí pro

Split(String, Int32, Int32)

Rozdělí vstupní řetězec zadanou maximální dobu 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 bude hledání začínat.

Návraty

String[]

Pole řetězců.

Výjimky

input je null.

startat je 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 výjimkou toho, ž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 nepostřebný zbytek řetězce. count Hodnota nuly poskytuje výchozí chování rozdělení co nejvícekrát. Parametr startat definuje bod, ve kterém začíná hledání prvního oddělovače (lze ho použít pro přeskočení úvodního prázdného místa).

Další podrobnosti o startat, viz poznámky oddílu Match(String, Int32).

Pokud se v řetězci countnenašly žádné shody z pozice +1, vrátí metoda pole 1 elementu, 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ž do jednoho znaku před shodu.

Pokud několik shod sousedí mezi sebou a počet nalezených shod je alespoň dva menší než count, vloží se do pole prázdný řetězec. Podobně platí, že pokud se najde shoda v startatřetězci, což je první znak v řetězci, první prvek vráceného pole je 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í, zda 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 následnému rozdělení řetězce maximálně třikrát počínaje danou pozicí. 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ětiznakových abecedních řetězců 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 se v regulárním výrazu používají zachytávání závorek, zachytávané texty se zahrnou do pole rozdělených řetězců. Všechny prvky pole obsahující zachycený text se však nezapočítávají při určování, zda bylo dosaženo countpočtu shod . Například rozdělení řetězce "jablko-meruňka-plum-pear-pomegranate-pineapple-peach" na maximálně čtyři podřetězce začínající na znak 15 v řetězci vede k sedmi prvků 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 obsahuje více sad zachytávání 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í součástí vráceného 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 zachytávání závorek k extrahování jednotlivých slov v řetězci. První sada zachycení závorek zachycuje spojovník a druhá sada zachycuje svislý pruh. Pokud je ukázkový kód zkompilován a spuštěn v rozhraní .NET Framework 1.0 nebo 1.1, vyloučí svislé znaky pruhu; 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 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 řetězců s jedním znakem, protože prázdný oddělovač řetězců lze najít v každém umístění. Následující příklad rozdělí řetězec "znaky" 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, vloží se na konec vráceného pole řetězec 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}

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

Návraty

String[]

Pole řetězců.

Výjimky

Došlo k chybě analýzy regulárního výrazu.

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 se nenajde žá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é ve voláních 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 několik shod spolu sousedí, vloží se do pole prázdný řetězec. Například rozdělení řetězce na jeden spojovník způsobí, že vrácená matice zahrne prázdný řetězec do pozice, kde jsou nalezeny dvě sousední spojovníky.

Pokud se najde shoda na začátku nebo na konci vstupního řetězce, je prázdný řetězec zahrnutý na začátku nebo na konci vráceného pole. Následující příklad používá vzor [a-z]+ regulárního výrazu k rozdělení vstupního řetězce na libovolné velké nebo malé abecední znaky. Protož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 výrazu Regex.Split používají zachytávání závorek, 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átí pole 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 zachytávání závorek, chování této metody závisí na verzi rozhraní .NET Framework. Pokud se v rozhraní .NET Framework 1.0 a 1.1 nenajde shoda v první sadě zachytávání závorek, zachycený text z dalších zachytávání závorek není součástí vráceného 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 zachytávání závorek k extrahování prvků data, včetně oddělovačů kalendářních dat, z řetězce kalendářního data. První sada zachycení závorek zachycuje spojovník a druhá sada zachycuje lomítko. Pokud je ukázkový kód zkompilová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 řetězců s jedním znakem, protože prázdný oddělovač řetězců lze najít v každém umístění.

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

Poznámky pro volající

Tato metoda vyprší 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čená statická metoda rozdělení textu na shodu vzorku je Split(String, String, RegexOptions, TimeSpan), která umožňuje nastavit časový limit.

Viz také

Platí pro

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 interval časového limitu, pokud nebyla 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čení, že metoda by neměla vypršel časový limit.

Návraty

String[]

Pole řetězců.

Výjimky

Došlo k chybě analýzy 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 se nenajde žá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é ve voláních 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 několik shod spolu sousedí, vloží se do pole prázdný řetězec. Například rozdělení řetězce na jeden spojovník způsobí, že vrácená matice zahrne prázdný řetězec do pozice, kde jsou nalezeny dvě sousední spojovníky.

Pokud se najde shoda na začátku nebo na konci vstupního řetězce, je prázdný řetězec zahrnutý na začátku nebo na konci vráceného pole. Následující příklad používá vzor [a-z]+ regulárního výrazu k rozdělení vstupního řetězce na libovolné velké nebo malé abecední znaky. Protož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 se ve výrazu Regex.Split používají zachytávání závorek, 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átí pole 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 zachytávání závorek, chování této metody závisí na verzi rozhraní .NET Framework. Pokud se v rozhraní .NET Framework 1.0 a 1.1 nenajde shoda v první sadě zachytávání závorek, zachycený text z dalších zachytávání závorek není součástí vráceného 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 zachytávání závorek k extrahování prvků data, včetně oddělovačů kalendářních dat, z řetězce kalendářního data. První sada zachycení závorek zachycuje spojovník a druhá sada zachycuje lomítko. Pokud je ukázkový kód zkompilová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 řetězců s jedním znakem, protože prázdný oddělovač řetězců lze najít v každém umístění.

Parametr matchTimeout určuje, jak dlouho se má metoda porovnávání vzorů pokusit najít shodu, než vyprší časový limit. Nastavení časového limitu zabrání regulárním výrazům, které spoléhají na nadměrné zpětné navracení, aby přestaly reagovat, když zpracovávají vstup, který obsahuje blízké shody. Další informace najdete v tématu Osvědčené postupy pro regulární výrazy a zpětné navracení. Pokud se v daném časovém intervalu nenajde žádná shoda, vyvolá metoda RegexMatchTimeoutException výjimku. matchTimeout přepíše výchozí hodnotu časového limitu definovanou pro doménu aplikace, ve které se metoda spustí.

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ého limitu zadáním InfiniteMatchTimeout, modul regulárních výrazů nabízí mírně lepší výkon. Časový limit byste ale měli zakázat pouze za následujících podmínek: – Při zpracování vstupu regulárním výrazem pochází 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é dynamicky zadali.

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

– Pokud vzor regulárního výrazu neobsahuje žádné prvky jazyka, které by při zpracování blízké shody způsobovaly nadměrné navracení.

Viz také

Platí pro