Regex.Split Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Text.RegularExpressions

Zestaw:: System.Text.RegularExpressions.dll

Zestaw:: System.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Dzieli ciąg wejściowy na tablicę podciągów w pozycjach zdefiniowanych przez dopasowanie wyrażenia regularnego.

Przeciążenia

Split(String, String, RegexOptions, TimeSpan)	Dzieli ciąg wejściowy na tablicę podciągów w pozycjach zdefiniowanych przez określony wzorzec wyrażenia regularnego. Dodatkowe parametry określają opcje, które modyfikują zgodną operację i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie.
Split(String, String, RegexOptions)	Dzieli ciąg wejściowy na tablicę podciągów w pozycjach zdefiniowanych przez określony wzorzec wyrażenia regularnego. Określone opcje modyfikują zgodną operację.
Split(String, Int32, Int32)	Dzieli ciąg wejściowy określoną maksymalną liczbę razy na tablicę podciągów w pozycjach zdefiniowanych przez wyrażenie regularne określone w konstruktorze Regex. Wyszukiwanie wzorca wyrażenia regularnego rozpoczyna się od określonej pozycji znaku w ciągu wejściowym.
Split(String, String)	Dzieli ciąg wejściowy na tablicę podciągów w pozycjach zdefiniowanych przez wzorzec wyrażenia regularnego.
Split(String)	Dzieli ciąg wejściowy na tablicę podciągów w pozycjach zdefiniowanych przez wzorzec wyrażenia regularnego określonego w konstruktorze Regex.
Split(String, Int32)	Dzieli ciąg wejściowy określoną maksymalną liczbę razy na tablicę podciągów w pozycjach zdefiniowanych przez wyrażenie regularne określone w konstruktorze Regex.

Split(String, String, RegexOptions, TimeSpan)

Źródło:: Regex.Split.cs

Źródło:: Regex.Split.cs

Źródło:: Regex.Split.cs

Dzieli ciąg wejściowy na tablicę podciągów w pozycjach zdefiniowanych przez określony wzorzec wyrażenia regularnego. Dodatkowe parametry określają opcje, które modyfikują zgodną operację i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie.

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

Ciąg do podzielenia.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

options: RegexOptions

Bitowa kombinacja wartości wyliczenia, które zapewniają opcje dopasowania.

matchTimeout: TimeSpan

Interwał limitu czasu lub InfiniteMatchTimeout wskazujący, że metoda nie powinna upłynął limit czasu.

Zwraca

String[]

Tablica ciągów.

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

input lub pattern jest null.

ArgumentOutOfRangeException

options nie jest prawidłową kombinacją bitową wartości RegexOptions.

-lub-

matchTimeout jest ujemna, zero lub większa niż około 24 dni.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Uwagi

Metody Regex.Split są podobne do metody String.Split(Char[]), z tą różnicą, że Regex.Split dzieli ciąg na ogranicznik określony przez wyrażenie regularne zamiast zestawu znaków. Ciąg jest podzielony jak najwięcej razy. Jeśli nie znaleziono ogranicznika, zwracana wartość zawiera jeden element, którego wartość jest oryginalnym ciągiem input.

Parametr pattern składa się z elementów języka wyrażeń regularnych, które symbolicznie opisują ciąg do dopasowania. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz .NET Regular Expressions and Regular Expression Language — Quick Reference.

Ważny

Skompilowane wyrażenia regularne używane w wywołaniach metod statycznych Split są automatycznie buforowane. Aby samodzielnie zarządzać okresem istnienia skompilowanych wyrażeń regularnych, użyj metod Split wystąpienia.

Jeśli wiele dopasowań sąsiaduje ze sobą, pusty ciąg zostanie wstawiony do tablicy. Na przykład podzielenie ciągu na jednym łączniku powoduje, że zwracana tablica zawiera pusty ciąg w miejscu, w którym znajdują się dwa sąsiadujące łączniki.

Jeśli dopasowanie zostanie znalezione na początku lub na końcu ciągu wejściowego, pusty ciąg zostanie uwzględniony na początku lub na końcu zwracanej tablicy. W poniższym przykładzie użyto wzorca wyrażenia regularnego [a-z]+, aby podzielić ciąg wejściowy na dowolną wielką lub małą literę alfabetyczną. Ponieważ ciąg rozpoczyna się i kończy się pasującymi znakami alfabetycznymi, wartość pierwszego i ostatniego elementu zwracanej tablicy jest 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', ''

Jeśli nawiasy przechwytywania są używane w wyrażeniu Regex.Split, każdy przechwycony tekst jest uwzględniony w wynikowej tablicy ciągów. Jeśli na przykład podzielisz ciąg "plum-pear" na łącznik umieszczony w nawiasach przechwytywania, zwracana tablica zawiera element ciągu zawierający łącznik.

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'

Jednak gdy wzorzec wyrażenia regularnego zawiera wiele zestawów przechwytywania nawiasów, zachowanie tej metody zależy od wersji programu .NET Framework. W programie .NET Framework 1.0 i 1.1, jeśli dopasowanie nie zostanie znalezione w pierwszym zestawie nawiasów przechwytywania, przechwycony tekst z dodatkowych nawiasów przechwytywania nie jest uwzględniony w zwracanej tablicy. Począwszy od programu .NET Framework 2.0, cały przechwycony tekst jest również dodawany do zwracanej tablicy. Na przykład poniższy kod używa dwóch zestawów przechwytywania nawiasów w celu wyodrębnienia elementów daty, w tym ograniczników dat z ciągu daty. Pierwszy zestaw przechwytywania nawiasów przechwytuje łącznik, a drugi zestaw przechwytuje ukośnik do przodu. Jeśli przykładowy kod jest kompilowany i uruchamiany w programie .NET Framework 1.0 lub 1.1, wyklucza znaki ukośnika; jeśli jest kompilowany i uruchamiany w wersji .NET Framework 2.0 lub nowszej, zawiera 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'

Jeśli wyrażenie regularne może być zgodne z pustym ciągiem, Split podzieli ciąg na tablicę ciągów jednoznakowych, ponieważ pusty ogranicznik ciągu można znaleźć w każdej lokalizacji.

Parametr matchTimeout określa, jak długo metoda dopasowania wzorca powinna próbować znaleźć dopasowanie przed upływem limitu czasu. Ustawienie interwału limitu czasu zapobiega wyrażeniom regularnym, które polegają na nadmiernym wycofywaniu, aby przestać odpowiadać podczas przetwarzania danych wejściowych, które zawierają niemal dopasowania. Aby uzyskać więcej informacji, zobacz Best Practices for Regular Expressions and Backtracking. Jeśli w tym interwale czasu nie znaleziono dopasowania, metoda zgłasza wyjątek RegexMatchTimeoutException. matchTimeout zastępuje domyślną wartość limitu czasu zdefiniowaną dla domeny aplikacji, w której jest wykonywana metoda.

Uwagi dotyczące wywoływania

Zalecamy ustawienie parametru matchTimeout na odpowiednią wartość, na przykład dwie sekundy. Jeśli wyłączysz limity czasu, określając InfiniteMatchTimeout, aparat wyrażeń regularnych zapewnia nieco lepszą wydajność. Należy jednak wyłączyć limity czasu tylko w następujących warunkach:

Gdy dane wejściowe przetwarzane przez wyrażenie regularne pochodzą ze znanego i zaufanego źródła lub składa się z tekstu statycznego. Wyklucza to tekst, który został dynamicznie wprowadzany przez użytkowników.
Gdy wzorzec wyrażenia regularnego został dokładnie przetestowany w celu zapewnienia, że efektywnie obsługuje dopasowania, niezgodne i bliskie dopasowania.
Gdy wzorzec wyrażenia regularnego nie zawiera żadnych elementów języka, które są znane, aby powodować nadmierne wycofywanie podczas przetwarzania niemal zgodnego.

Zobacz też

elementy języka wyrażeń regularnych

Dotyczy

Split(String, String, RegexOptions)

Źródło:: Regex.Split.cs

Źródło:: Regex.Split.cs

Źródło:: Regex.Split.cs

Dzieli ciąg wejściowy na tablicę podciągów w pozycjach zdefiniowanych przez określony wzorzec wyrażenia regularnego. Określone opcje modyfikują zgodną operację.

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

Ciąg do podzielenia.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

options: RegexOptions

Bitowa kombinacja wartości wyliczenia, które zapewniają opcje dopasowania.

Zwraca

String[]

Tablica ciągów.

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

input lub pattern jest null.

ArgumentOutOfRangeException

options nie jest prawidłową kombinacją bitową wartości RegexOptions.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Uwagi

Ważny

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

Jeśli wyrażenie regularne może być zgodne z pustym ciągiem, Split podzieli ciąg na tablicę ciągów jednoznakowych, ponieważ pusty ogranicznik ciągu można znaleźć w każdej lokalizacji.

Wyjątek RegexMatchTimeoutException jest zgłaszany, jeśli czas wykonywania operacji podziału przekracza interwał limitu czasu określony dla domeny aplikacji, w której jest wywoływana metoda. Jeśli w właściwościach domeny aplikacji nie zdefiniowano limitu czasu lub jeśli wartość limitu czasu jest Regex.InfiniteMatchTimeout, nie jest zgłaszany żaden wyjątek.

Uwagi dotyczące wywoływania

Ta metoda powoduje przekroczenie limitu czasu po interwale równym domyślnej wartości limitu czasu domeny aplikacji, w której jest wywoływana metoda. Jeśli dla domeny aplikacji nie zdefiniowano wartości limitu czasu, zostanie użyta wartość InfiniteMatchTimeout, która uniemożliwia przekroczenie limitu czasu metody. Zalecaną metodą statyczną dzielenia tekstu na dopasowaniu wzorca jest Split(String, String, RegexOptions, TimeSpan), która umożliwia ustawienie interwału limitu czasu.

Zobacz też

elementy języka wyrażeń regularnych

Dotyczy

Split(String, Int32, Int32)

Źródło:: Regex.Split.cs

Źródło:: Regex.Split.cs

Źródło:: Regex.Split.cs

Dzieli ciąg wejściowy określoną maksymalną liczbę razy na tablicę podciągów w pozycjach zdefiniowanych przez wyrażenie regularne określone w konstruktorze Regex. Wyszukiwanie wzorca wyrażenia regularnego rozpoczyna się od określonej pozycji znaku w ciągu wejściowym.

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

Ciąg, który ma zostać podzielony.

count: Int32

Maksymalna liczba wystąpień podziału.

startat: Int32

Pozycja znaku w ciągu wejściowym, w którym rozpocznie się wyszukiwanie.

Zwraca

String[]

Tablica ciągów.

Wyjątki

ArgumentNullException

input jest null.

ArgumentOutOfRangeException

startat jest mniejsza niż zero lub większa niż długość input.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Uwagi

Metody Regex.Split są podobne do metody String.Split, z tą różnicą, że Regex.Split dzieli ciąg na ogranicznik określony przez wyrażenie regularne zamiast zestawu znaków. Parametr count określa maksymalną liczbę podciągów, w których jest podzielony ciąg input; ostatni ciąg zawiera niesplitową pozostałą część ciągu. Wartość count zero zapewnia domyślne zachowanie dzielenia jak najwięcej razy. Parametr startat definiuje punkt, w którym rozpoczyna się wyszukiwanie pierwszego ogranicznika (można go użyć do pomijania wiodącego odstępu).

Aby uzyskać więcej informacji na temat startat, zobacz sekcję Uwagi Match(String, Int32).

Jeśli nie znaleziono dopasowań z pozycji count+1 w ciągu, metoda zwraca tablicę jednoelementową zawierającą ciąg input. Jeśli zostanie znaleziona jedna lub więcej dopasowań, pierwszy element zwracanej tablicy zawiera pierwszą część ciągu od pierwszego znaku do jednego znaku przed dopasowaniem.

Jeśli wiele dopasowań sąsiaduje ze sobą, a liczba znalezionych dopasowań jest co najmniej dwie mniejsze niż count, pusty ciąg zostanie wstawiony do tablicy. Podobnie, jeśli dopasowanie zostanie znalezione w startat, który jest pierwszym znakiem w ciągu, pierwszy element zwracanej tablicy jest pustym ciągiem. Oznacza to, że puste ciągi wynikowe z sąsiednich dopasowań są liczone w celu określenia, czy liczba pasujących podciągów jest równa count. W poniższym przykładzie wyrażenie regularne \d+ służy do znajdowania pozycji początkowej pierwszego podciągu znaków liczbowych w ciągu, a następnie dzielenia ciągu maksymalnie trzy razy rozpoczynającego się od tej pozycji. Ponieważ wzorzec wyrażenia regularnego pasuje do początku ciągu wejściowego, zwracana tablica ciągów składa się z pustego ciągu, ciągu alfabetycznego z pięcioma znakami i pozostałej części ciągu,

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'

Jeśli nawiasy przechwytywania są używane w wyrażeniu regularnym, każdy przechwycony tekst jest uwzględniony w tablicy podzielonych ciągów. Jednak wszystkie elementy tablicy zawierające przechwycony tekst nie są liczone w określaniu, czy liczba dopasowań osiągnęła count. Na przykład podzielenie ciągu "apple-apricot-plum-pear-pomegranate-pineapple-peach" na maksymalnie cztery podciągnięcia rozpoczynające się od znaku 15 w ciągu powoduje utworzenie tablicy siedmiu elementów, jak pokazano w poniższym kodzie.

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'

Jednak gdy wzorzec wyrażenia regularnego zawiera wiele zestawów przechwytywania nawiasów, zachowanie tej metody zależy od wersji programu .NET Framework. W programie .NET Framework 1.0 i 1.1, jeśli dopasowanie nie zostanie znalezione w pierwszym zestawie nawiasów przechwytywania, przechwycony tekst z dodatkowych nawiasów przechwytywania nie jest uwzględniony w zwracanej tablicy. Począwszy od programu .NET Framework 2.0, cały przechwycony tekst jest również dodawany do zwracanej tablicy. Na przykład poniższy kod używa dwóch zestawów przechwytywania nawiasów w celu wyodrębnienia pojedynczych wyrazów w ciągu. Pierwszy zestaw przechwytywania nawiasów przechwytuje łącznik, a drugi zestaw przechwytuje pionowy pasek. Jeśli przykładowy kod jest kompilowany i uruchamiany w programie .NET Framework 1.0 lub 1.1, wyklucza znaki pionowego paska; jeśli jest kompilowany i uruchamiany w wersji .NET Framework 2.0 lub nowszej, zawiera 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'

Jeśli wyrażenie regularne może być zgodne z pustym ciągiem, Split podzieli ciąg na tablicę ciągów jednoznakowych, ponieważ pusty ogranicznik ciągu można znaleźć w każdej lokalizacji. Poniższy przykład dzieli ciąg "znaki" na tyle elementów, ile zawiera ciąg wejściowy, zaczynając od znaku "a". Ponieważ ciąg null jest zgodny z końcem ciągu wejściowego, na końcu zwracanej tablicy wstawiany jest ciąg o wartości 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}

Wyjątek RegexMatchTimeoutException jest zgłaszany, jeśli czas wykonywania operacji podziału przekracza interwał limitu czasu określony przez konstruktora Regex.Regex(String, RegexOptions, TimeSpan). Jeśli nie ustawisz interwału przekroczenia limitu czasu podczas wywoływania konstruktora, wyjątek jest zgłaszany, jeśli operacja przekracza wartość limitu czasu ustanowioną dla domeny aplikacji, w której jest tworzony obiekt Regex. Jeśli limit czasu nie jest zdefiniowany w wywołaniu konstruktora Regex lub we właściwościach domeny aplikacji lub jeśli wartość limitu czasu jest Regex.InfiniteMatchTimeout, nie jest zgłaszany wyjątek

Zobacz też

język wyrażeń regularnych — krótki przewodnik

Dotyczy

Split(String, String)

Źródło:: Regex.Split.cs

Źródło:: Regex.Split.cs

Źródło:: Regex.Split.cs

Dzieli ciąg wejściowy na tablicę podciągów w pozycjach zdefiniowanych przez wzorzec wyrażenia regularnego.

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

Ciąg do podzielenia.

pattern: String

Wzorzec wyrażenia regularnego do dopasowania.

Zwraca

String[]

Tablica ciągów.

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

input lub pattern jest null.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Uwagi

Metody Regex.Split są podobne do metody String.Split, z tą różnicą, że Regex.Split dzieli ciąg na ogranicznik określony przez wyrażenie regularne zamiast zestawu znaków. Ciąg input jest podzielony jak najwięcej razy. Jeśli pattern nie zostanie znaleziona w ciągu input, zwracana wartość zawiera jeden element, którego wartość jest oryginalnym ciągiem input.

Ważny

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'

Jeśli dopasowanie zostanie znalezione na początku lub na końcu ciągu wejściowego, pusty ciąg zostanie uwzględniony na początku lub na końcu zwracanej tablicy. W poniższym przykładzie użyto wzorca wyrażenia regularnego \d+ w celu podzielenia ciągu wejściowego na znaki liczbowe. Ponieważ ciąg rozpoczyna się i kończy się pasującymi znakami liczbowymi, wartość pierwszego i ostatniego elementu zwracanej tablicy jest String.Empty.

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

Zwróć uwagę, że zwracana tablica zawiera również pusty ciąg na początku i na końcu tablicy.

Uwagi dotyczące wywoływania

Zobacz też

elementy języka wyrażeń regularnych

Dotyczy

Split(String)

Źródło:: Regex.Split.cs

Źródło:: Regex.Split.cs

Źródło:: Regex.Split.cs

Dzieli ciąg wejściowy na tablicę podciągów w pozycjach zdefiniowanych przez wzorzec wyrażenia regularnego określonego w konstruktorze 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

Ciąg do podzielenia.

Zwraca

String[]

Tablica ciągów.

Wyjątki

ArgumentNullException

input jest null.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Uwagi

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'

Jeśli dopasowanie zostanie znalezione na początku lub na końcu ciągu wejściowego, pusty ciąg zostanie uwzględniony na początku lub na końcu zwracanej tablicy. W poniższym przykładzie użyto wzorca wyrażenia regularnego \d+ w celu podzielenia ciągu wejściowego na znaki liczbowe. Ponieważ ciąg rozpoczyna się i kończy się pasującymi znakami liczbowymi, wartość pierwszego i ostatniego elementu zwracanej tablicy jest 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', ''

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

Jeśli wyrażenie regularne może być zgodne z pustym ciągiem, Split(String) podzieli ciąg na tablicę ciągów jednoznakowych, ponieważ pusty ogranicznik ciągu można znaleźć w każdej lokalizacji. Na przykład:

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

Zwróć uwagę, że zwracana tablica zawiera również pusty ciąg na początku i na końcu tablicy.

Zobacz też

język wyrażeń regularnych — krótki przewodnik

Dotyczy

Split(String, Int32)

Źródło:: Regex.Split.cs

Źródło:: Regex.Split.cs

Źródło:: Regex.Split.cs

Dzieli ciąg wejściowy określoną maksymalną liczbę razy na tablicę podciągów w pozycjach zdefiniowanych przez wyrażenie regularne określone w konstruktorze 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

Ciąg, który ma zostać podzielony.

count: Int32

Maksymalna liczba wystąpień podziału.

Zwraca

String[]

Tablica ciągów.

Wyjątki

ArgumentNullException

input jest null.

RegexMatchTimeoutException

Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.

Uwagi

Metody Regex.Split są podobne do metody String.Split, z tą różnicą, że Regex.Split dzieli ciąg na ogranicznik określony przez wyrażenie regularne zamiast zestawu znaków. Parametr count określa maksymalną liczbę podciągów, w których można podzielić ciąg input; ostatni ciąg zawiera niesplitową pozostałą część ciągu. Wartość count zero zapewnia domyślne zachowanie dzielenia jak najwięcej razy.

Jeśli wiele dopasowań sąsiaduje ze sobą lub jeśli dopasowanie zostanie znalezione na początku lub na końcu input, a liczba znalezionych dopasowań wynosi co najmniej dwa mniej niż count, pusty ciąg zostanie wstawiony do tablicy. Oznacza to, że puste ciągi wynikowe z sąsiednich dopasowań lub z dopasowań na początku lub na końcu ciągu wejściowego są liczone w określaniu, czy liczba pasujących podciągów jest równa count. W poniższym przykładzie wyrażenie regularne /d+ służy do dzielenia ciągu wejściowego zawierającego co najmniej jedną cyfrę dziesiętną na maksymalnie trzy podciągi. Ponieważ początek ciągu wejściowego jest zgodny ze wzorcem wyrażenia regularnego, pierwszy element tablicy zawiera String.Empty, drugi zawiera pierwszy zestaw znaków alfabetycznych w ciągu wejściowym, a trzeci zawiera pozostałą część ciągu, który następuje po trzecim dopasowaniu.

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'

Jeśli nawiasy przechwytywania są używane w wyrażeniu regularnym, każdy przechwycony tekst jest uwzględniony w tablicy podzielonych ciągów. Jednak wszystkie elementy tablicy zawierające przechwycony tekst nie są liczone w określaniu, czy liczba dopasowań osiągnęła count. Na przykład podzielenie ciągu "apple-apricot-plum-pear-banana" na maksymalnie cztery podciągnięcia powoduje utworzenie tablicy siedmiu elementów, jak pokazano w poniższym kodzie.

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'

Jednak gdy wzorzec wyrażenia regularnego zawiera wiele zestawów przechwytywania nawiasów, zachowanie tej metody zależy od wersji programu .NET Framework. W programie .NET Framework 1.0 i 1.1 w zwracanej tablicy znajduje się tylko przechwycony tekst z pierwszego zestawu nawiasów przechwytywania. Począwszy od programu .NET Framework 2.0, cały przechwycony tekst jest dodawany do zwracanej tablicy. Jednak elementy w zwracanej tablicy zawierającej przechwycony tekst nie są liczone w celu określenia, czy liczba pasujących podciągów jest równa count. Na przykład w poniższym kodzie wyrażenie regularne używa dwóch zestawów przechwytywania nawiasów w celu wyodrębnienia elementów daty z ciągu daty. Pierwszy zestaw przechwytywania nawiasów przechwytuje łącznik, a drugi zestaw przechwytuje ukośnik do przodu. Wywołanie metody Split(String, Int32) określa maksymalnie dwa elementy w zwracanej tablicy. Jeśli przykładowy kod jest kompilowany i uruchamiany w programie .NET Framework 1.0 lub 1.1, metoda zwraca tablicę ciągów dwuelementowych. Jeśli jest on kompilowany i uruchamiany w wersji .NET Framework 2.0 lub nowszej, metoda zwraca tablicę ciągów z trzema elementami.

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'

Jeśli wyrażenie regularne może być zgodne z pustym ciągiem, Split(String, Int32) podzieli ciąg na tablicę ciągów jednoznakowych, ponieważ pusty ogranicznik ciągu można znaleźć w każdej lokalizacji. Poniższy przykład dzieli ciąg "znaki" na tyle elementów, ile znajduje się w ciągu wejściowym. Ponieważ ciąg null pasuje do początku ciągu wejściowego, ciąg null jest wstawiany na początku zwracanej tablicy. Powoduje to, że dziesiąty element składa się z dwóch znaków na końcu ciągu wejściowego.

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}

Zobacz też

język wyrażeń regularnych — krótki przewodnik

Dotyczy

Udostępnij za pośrednictwem

Regex.Split Metoda

Definicja

Przeciążenia

Split(String, String, RegexOptions, TimeSpan)

Parametry

Zwraca

Wyjątki

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

Split(String, String, RegexOptions)

Parametry

Zwraca

Wyjątki

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

Split(String, Int32, Int32)

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

Split(String, String)

Parametry

Zwraca

Wyjątki

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

Split(String)

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

Split(String, Int32)

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

Dodatkowe zasoby