Sdílet prostřednictvím

Regex.Split Metoda

  • Reference

Definice

Obor názvů:
System.Text.RegularExpressions
Sestavení:
System.Text.RegularExpressions.dll
Sestavení:
System.dll
Sestavení:
netstandard.dll

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, 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 se nenajde žádná shoda.
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, 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)

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

Zdroj:
Regex.Split.cs
Zdroj:
Regex.Split.cs
Zdroj:
Regex.Split.cs

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 se nenajde žá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

Časový limit nebo InfiniteMatchTimeout označující, že metoda by neměla časového limitu časového limitu.

Návraty

String[]

Pole řetězců.

Výjimky

ArgumentException

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

ArgumentNullException

input nebo pattern je null.

ArgumentOutOfRangeException

options není platná bitové kombinace RegexOptions hodnot.

-nebo-

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

RegexMatchTimeoutException

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

Poznámky

Regex.Split metody jsou podobné metodě String.Split(Char[]) 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ích výrazů .NET a jazyk regulárních výrazů – stručná referenční.

Důležitý

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

Pokud spolu sousedí více shod, vloží se do pole prázdný řetězec. Například rozdělení řetězce na jedno pomlčky způsobí, že vrácená pole bude obsahovat prázdný řetězec na pozici, kde jsou nalezeny dvě sousední pomlč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 regulárního výrazu [a-z]+ k rozdělení vstupního řetězce na libovolné velká nebo malá písmena abecední znak. 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žijí 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íku umístěném v zachytávání závorek, bude vrácená matice obsahovat 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 se do vráceného pole nezahrne. 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 extrakci 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 regulární výraz může odpovídat prázdnému řetězci, 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í intervalu časového limitu brání regulárním výrazům, které spoléhají na nadměrné navracení, aby přestaly reagovat při zpracování vstupu, který obsahuje téměř shody. Další informace najdete v tématu Osvědčené postupy pro regulární výrazy a zpětného 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 spouští.

Poznámky pro volající

Doporučujeme nastavit parametr matchTimeout 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é limity byste ale měli zakázat pouze za následujících podmínek:

  • Pokud 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é dynamicky zadali.

  • 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.

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

Viz také

Platí pro

Split(String, String, RegexOptions)

Zdroj:
Regex.Split.cs
Zdroj:
Regex.Split.cs
Zdroj:
Regex.Split.cs

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

ArgumentException

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

ArgumentNullException

input nebo pattern je null.

ArgumentOutOfRangeException

options není platná bitové kombinace RegexOptions hodnot.

RegexMatchTimeoutException

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

Poznámky

Regex.Split metody jsou podobné metodě String.Split(Char[]) 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ích výrazů .NET a jazyk regulárních výrazů – stručná referenční.

Důležitý

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

Pokud spolu sousedí více shod, vloží se do pole prázdný řetězec. Například rozdělení řetězce na jedno pomlčky způsobí, že vrácená pole bude obsahovat prázdný řetězec na pozici, kde jsou nalezeny dvě sousední pomlč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 regulárního výrazu [a-z]+ k rozdělení vstupního řetězce na libovolné velká nebo malá písmena abecední znak. 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žijí 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íku umístěném v zachytávání závorek, bude vrácená matice obsahovat 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 se do vráceného pole nezahrne. 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 extrakci 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 regulární výraz může odpovídat prázdnému řetězci, 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 je vyvolána, 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 žádný časový limit ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá 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é 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 interval časového limitu.

Viz také

Platí pro

Split(String, Int32, Int32)

Zdroj:
Regex.Split.cs
Zdroj:
Regex.Split.cs
Zdroj:
Regex.Split.cs

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

ArgumentNullException

input je null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

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

Poznámky

Regex.Split metody jsou podobné metodě String.Split 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 je řetězec input rozdělen; Poslední řetězec obsahuje neposvícený zbytek řetězce. Hodnota count 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 (to se dá použít pro přeskočení úvodního prázdného místa).

Další podrobnosti o startatnaleznete v části Poznámky Match(String, Int32).

Pokud se v řetězci nenajde žádná shoda z pozice count+1, vrátí metoda pole s jedním prvkem, které obsahuje řetězec input. 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 spolu sousedí více shod a počet nalezených shod je alespoň dva menší než count, vloží se do pole prázdný řetězec. Podobně platí, že pokud je nalezena shoda v startat, 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 k rozdělení řetězce maximálně třikrát začínajícího na této pozici. 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ísícové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 se v regulárním výrazu používají zachytávání závorek, zahrne se do pole rozdělených řetězců veškerý zachycený text. Všechny prvky pole, které obsahují zachycený text, se však nezapočítávají při určování, zda počet shod dosáhl count. 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 má za následek pole se sedmi prvky, 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. 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 se do vráceného pole nezahrne. 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 extrakci jednotlivých slov v řetězci. První sada zachycení závorek zachycuje spojovník a druhá sada zachycuje svislou čáru. Pokud je příklad kódu 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 regulární výraz může odpovídat prázdnému řetězci, 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 "characters" na tolik prvků, kolik vstupní řetězec obsahuje, počínaje znakem "a". Protož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čí č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čí hodnotu časového limitu vytvořenou pro doménu aplikace, ve které je vytvořen objekt Regex. Pokud není definován časový limit ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

Viz také

Platí pro

Split(String, String)

Zdroj:
Regex.Split.cs
Zdroj:
Regex.Split.cs
Zdroj:
Regex.Split.cs

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

ArgumentException

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

ArgumentNullException

input nebo pattern je null.

RegexMatchTimeoutException

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

Poznámky

Regex.Split metody jsou podobné metodě String.Split 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 je rozdělený co nejvícekrát. Pokud pattern v řetězci input nenajdete, návratová hodnota obsahuje jeden prvek, jehož hodnota je původní řetězec input.

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ích výrazů .NET a jazyk regulárních výrazů – stručná referenční.

Důležitý

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

Pokud spolu sousedí více shod, vloží se do pole prázdný řetězec. Například rozdělení řetězce na jedno pomlčky způsobí, že vrácená matice bude obsahovat prázdný řetězec na pozici, 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 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 regulárního výrazu \d+ 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žijí 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íku umístěném v zachytávání závorek, bude vrácená matice obsahovat 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 se do vráceného pole nezahrne. 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 extrakci 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 regulární výraz může odpovídat prázdnému řetězci, 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í. Napří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', ''}

Vrácená matice také obsahuje prázdný řetězec na začátku a na konci pole.

Výjimka RegexMatchTimeoutException je vyvolána, 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 žádný časový limit ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá 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é 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 interval časového limitu.

Viz také

Platí pro

Split(String)

Zdroj:
Regex.Split.cs
Zdroj:
Regex.Split.cs
Zdroj:
Regex.Split.cs

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

ArgumentNullException

input je null.

RegexMatchTimeoutException

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

Poznámky

Regex.Split metody jsou podobné metodě String.Split(Char[]) 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 spolu sousedí více shod, vloží se do pole prázdný řetězec. Například rozdělení řetězce na jedno pomlčky způsobí, že vrácená matice bude obsahovat prázdný řetězec na pozici, 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()
   {
      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 regulárního výrazu \d+ 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žijí 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íku umístěném v zachytávání závorek, bude vrácená matice obsahovat 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 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 se do vráceného pole nezahrne. 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 extrakci 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 = @"(-)|(/)";
      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 může odpovídat prázdnému řetězci, Split(String) 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í. Napří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, }

Vrácená matice také obsahuje prázdný řetězec na začátku a na konci pole.

Výjimka RegexMatchTimeoutException je vyvolána, 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čí hodnotu časového limitu vytvořenou pro doménu aplikace, ve které je vytvořen objekt Regex. Pokud není definován časový limit ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

Viz také

Platí pro

Split(String, Int32)

Zdroj:
Regex.Split.cs
Zdroj:
Regex.Split.cs
Zdroj:
Regex.Split.cs

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

ArgumentNullException

input je null.

RegexMatchTimeoutException

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

Poznámky

Regex.Split metody jsou podobné metodě String.Split 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 lze řetězec input rozdělit; Poslední řetězec obsahuje neposvícený zbytek řetězce. Hodnota count nuly poskytuje výchozí chování rozdělení co nejvícekrát.

Pokud spolu sousedí více shod nebo pokud je nalezena shoda na začátku nebo 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é jsou výsledkem 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 String.Empty, druhý obsahuje první sadu abecedních znaků ve vstupním řetězci a třetí obsahuje zbytek řetězce, který následuje za třetí shodou.

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, zahrne se do pole rozdělených řetězců veškerý zachycený text. Všechny prvky pole, které obsahují zachycený text, se však nezapočítávají při určování, zda počet shod dosáhl count. Například rozdělením řetězce "apple-meruňka-plum-pear-banana" na maximálně čtyři podřetězce vznikne sedmiprvková matice, 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 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 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 ve 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ětců rovná count. Například v následujícím kódu používá regulární výraz dvě sady zachycení závorek k extrahování prvků data z řetězce kalendářního data. První sada zachycení závorek zachycuje spojovník a druhá sada zachycuje lomítko. Volání metody Split(String, Int32) pak určuje maximálně dva prvky ve vrácené matici. Pokud je příklad kódu zkompilován a spuštěn v rozhraní .NET Framework 1.0 nebo 1.1, metoda vrátí pole řetězce se dvěma prvky. Pokud je zkompilována a spuštěna v rozhraní .NET Framework 2.0 nebo novějších verzích, 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 regulární výraz může odpovídat prázdnému řetězci, Split(String, Int32) 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 je ve vstupním řetězci. Protož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čí č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čí hodnotu časového limitu vytvořenou pro doménu aplikace, ve které je vytvořen objekt Regex. Pokud není definován časový limit ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace nebo pokud je hodnota časového limitu Regex.InfiniteMatchTimeout, nevyvolá se žádná výjimka.

Viz také

Platí pro