Regex.Split Metoda
Definicja
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) |
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) |
Dzieli ciąg wejściowy na tablicę podciągów na pozycjach zdefiniowanych przez wzorzec wyrażenia regularnego. |
| 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, RegexOptions) |
Dzieli ciąg wejściowy na tablicę podciągów na pozycjach zdefiniowanych przez określony wzorzec wyrażenia regularnego. Określone opcje modyfikują odpowiednią operację. |
| Split(String, String, RegexOptions, TimeSpan) |
Dzieli ciąg wejściowy na tablicę podciągów na pozycjach zdefiniowanych przez określony wzorzec wyrażenia regularnego. Dodatkowe parametry określają opcje modyfikujące pasującą operację i interwał limitu czasu, jeśli nie zostanie znalezione dopasowanie. |
Split(String)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- 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
Tablica ciągów.
Wyjątki
input to null.
Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.
Uwagi
Metody Regex.Split są podobne do String.Split(Char[]) metody, 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 wejściowym.
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 zwrócona tablica będzie zawierać pusty ciąg w miejscu, w którym znajdują się dwa sąsiadujące łączniki, jak pokazano w poniższym kodzie.
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 zwróconej tablicy. W poniższym przykładzie użyto wzorca \d+ wyrażenia regularnego, aby podzielić ciąg wejściowy na znaki liczbowe. Ponieważ ciąg zaczyna się i kończy się pasującymi znakami liczbowymi, wartość pierwszego i ostatniego elementu zwracanej tablicy to 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', ''
Jeśli nawiasy przechwytywania są używane w wyrażeniu Regex.Split , dowolny 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()
{
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'
Jednak gdy wzorzec wyrażenia regularnego zawiera wiele zestawów nawiasów przechwytywania, zachowanie tej metody zależy od wersji .NET Framework. W .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 .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 .NET Framework 1.0 lub 1.1, wyklucza znaki ukośnika. Jeśli jest kompilowany i uruchamiany w .NET Framework 2.0 lub nowszych wersjach, zawiera 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'
Jeśli wyrażenie regularne może być zgodne z pustym ciągiem, podzieli ciąg na tablicę ciągów jednoznakowych, Split(String) ponieważ pusty ogranicznik ciągu można znaleźć w każdej lokalizacji. 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.
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 dowolną wartość limitu czasu ustanowioną dla domeny aplikacji, w której Regex jest tworzony obiekt. Jeśli w Regex wywołaniu konstruktora lub we właściwościach domeny aplikacji nie zdefiniowano limitu czasu lub jeśli wartość limitu czasu wynosi Regex.InfiniteMatchTimeout, nie jest zgłaszany żaden wyjątek
Zobacz też
Dotyczy
Split(String, Int32)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- 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
Tablica ciągów.
Wyjątki
input to null.
Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.
Uwagi
Metody Regex.Split są podobne do String.Split metody, 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 input można podzielić ciąg; ostatni ciąg zawiera niesplitową pozostałą część ciągu. Wartość count zero zapewnia domyślne zachowanie dzielenia tak wiele razy, jak to możliwe.
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ń jest co najmniej dwie mniejsze niż count, pusty ciąg zostanie wstawiony do tablicy. Oznacza to, że puste ciągi wynikowe z sąsiednich dopasowań lub 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 /d+ regularne jest używane do dzielenia ciągu wejściowego zawierającego co najmniej jedną cyfrę dziesiętną do maksymalnie trzech podciągów. Ponieważ początek ciągu wejściowego pasuje do wzorca 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 ciągów podzielonych. Jednak wszystkie elementy tablicy zawierające przechwycony tekst nie są liczone w określaniu, czy liczba dopasowań osiągnęła countwartość . Na przykład podzielenie ciągu "apple-apricot-plum-pear-banana" na maksymalnie cztery podciągnięcia powoduje wyświetlenie 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 nawiasów przechwytywania, zachowanie tej metody zależy od wersji .NET Framework. W .NET Framework 1.0 i 1.1 w zwracanej tablicy znajduje się tylko przechwycony tekst z pierwszego zestawu nawiasów przechwytywania. Począwszy od .NET Framework 2.0, do zwracanej tablicy zostanie dodany cały przechwycony tekst. Jednak elementy w zwracanej tablicy zawierającej przechwycony tekst nie są liczone w określaniu, 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 Split(String, Int32) metody następnie określa maksymalnie dwa elementy w zwracanej tablicy. Jeśli przykładowy kod jest kompilowany i uruchamiany w .NET Framework 1.0 lub 1.1, metoda zwraca tablicę ciągów dwuelementowych. Jeśli jest on kompilowany i uruchamiany w .NET Framework wersji 2.0 lub nowszych, metoda zwraca tablicę ciągów trzech elementów.
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, podzieli ciąg na tablicę ciągów jednoznakowych, Split(String, Int32) 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}
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 dowolną wartość limitu czasu ustanowioną dla domeny aplikacji, w której Regex jest tworzony obiekt. Jeśli w Regex wywołaniu konstruktora lub we właściwościach domeny aplikacji nie zdefiniowano limitu czasu lub jeśli wartość limitu czasu wynosi Regex.InfiniteMatchTimeout, nie jest zgłaszany żaden wyjątek
Zobacz też
Dotyczy
Split(String, String)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Dzieli ciąg wejściowy na tablicę podciągów na 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
Tablica ciągów.
Wyjątki
Wystąpił błąd analizowania wyrażeń regularnych.
input lub pattern to null.
Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.
Uwagi
Metody Regex.Split są podobne do String.Split metody, 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 ciąg nie zostanie znaleziony input , zwracana wartość zawiera jeden element, którego wartość jest oryginalnym input ciągiem.
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 (Wyrażenia regularne platformy .NET i język wyrażeń regularnych — szybki przewodnik).
Ważne
Skompilowane wyrażenia regularne używane w wywołaniach do metod statycznych Split są automatycznie buforowane. Aby samodzielnie zarządzać okresem istnienia skompilowanych wyrażeń regularnych, użyj metod wystąpienia Split .
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 zwrócona tablica będzie zawierać pusty ciąg w miejscu, w którym znajdują się dwa sąsiadujące łączniki, jak pokazano w poniższym kodzie.
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 zwróconej tablicy. W poniższym przykładzie użyto wzorca \d+ wyrażenia regularnego, aby podzielić ciąg wejściowy na znaki liczbowe. Ponieważ ciąg zaczyna się i kończy się pasującymi znakami liczbowymi, wartość pierwszego i ostatniego elementu zwracanej tablicy to 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', ''
Jeśli nawiasy przechwytywania są używane w wyrażeniu Regex.Split , dowolny 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 nawiasów przechwytywania, zachowanie tej metody zależy od wersji .NET Framework. W .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 .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 .NET Framework 1.0 lub 1.1, wyklucza znaki ukośnika. Jeśli jest kompilowany i uruchamiany w .NET Framework 2.0 lub nowszych wersjach, 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, podzieli ciąg na tablicę ciągów jednoznakowych, Split ponieważ pusty ogranicznik ciągu można znaleźć w każdej lokalizacji. Przykład:
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.
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 wynosi Regex.InfiniteMatchTimeout, nie zostanie zgłoszony 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ż
Dotyczy
Split(String, Int32, Int32)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- 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
Tablica ciągów.
Wyjątki
input to null.
startat jest mniejsza niż zero lub większa niż długość obiektu input.
Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.
Uwagi
Metody Regex.Split są podobne do String.Split metody, 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 input jest podzielony ciąg; ostatni ciąg zawiera niesplitową resztę ciągu. Wartość count zero zapewnia domyślne zachowanie dzielenia tak wiele razy, jak to możliwe. 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 startatprogramu , zobacz sekcję Uwagi w temacie Match(String, Int32).
Jeśli nie znaleziono dopasowań z countpozycji +1 w ciągu, metoda zwraca tablicę jednoelementową zawierającą input ciąg. 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 startatelemecie , który jest pierwszym znakiem w ciągu, pierwszym elementem zwracanej tablicy jest pusty ciąg. Oznacza to, że puste ciągi wynikowe z sąsiednich dopasowań są liczone w określaniu, czy liczba pasujących podciągów jest równa count. W poniższym przykładzie wyrażenie \d+ regularne służy do znajdowania pozycji początkowej pierwszego podciągu znaków liczbowych w ciągu, a następnie podzielenia 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 ciągów podzielonych. Jednak wszystkie elementy tablicy zawierające przechwycony tekst nie są liczone w określaniu, czy liczba dopasowań osiągnęła countwartość . 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 wyświetlenie 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 nawiasów przechwytywania, zachowanie tej metody zależy od wersji .NET Framework. W .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 .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, aby wyodrębnić poszczególne wyrazy 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 .NET Framework 1.0 lub 1.1, wyklucza on znaki pionowego paska; jeśli jest kompilowany i uruchamiany w .NET Framework 2.0 lub nowszych wersjach, 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, podzieli ciąg na tablicę ciągów jednoznakowych, Split 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, ciąg null jest wstawiany na końcu zwracanej tablicy.
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 dowolną wartość limitu czasu ustanowioną dla domeny aplikacji, w której Regex jest tworzony obiekt. Jeśli w Regex wywołaniu konstruktora lub we właściwościach domeny aplikacji nie zdefiniowano limitu czasu lub jeśli wartość limitu czasu wynosi Regex.InfiniteMatchTimeout, nie jest zgłaszany żaden wyjątek
Zobacz też
Dotyczy
Split(String, String, RegexOptions)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Dzieli ciąg wejściowy na tablicę podciągów na pozycjach zdefiniowanych przez określony wzorzec wyrażenia regularnego. Określone opcje modyfikują odpowiednią 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
Tablica ciągów.
Wyjątki
Wystąpił błąd analizowania wyrażeń regularnych.
input lub pattern to null.
options nie jest prawidłową kombinacją bitów RegexOptions wartości.
Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.
Uwagi
Metody Regex.Split są podobne do String.Split(Char[]) metody, 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 input ciągiem.
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 (Wyrażenia regularne platformy .NET i język wyrażeń regularnych — szybki przewodnik).
Ważne
Skompilowane wyrażenia regularne używane w wywołaniach do metod statycznych Split są automatycznie buforowane. Aby samodzielnie zarządzać okresem istnienia skompilowanych wyrażeń regularnych, użyj metod wystąpienia Split .
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 zwrócona tablica będzie 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 zwróconej tablicy. W poniższym przykładzie użyto wzorca [a-z]+ wyrażenia regularnego, aby podzielić ciąg wejściowy na dowolną wielką lub małą literę alfabetyczną. Ponieważ ciąg zaczyna się i kończy się pasującymi znakami alfabetycznymi, wartość pierwszego i ostatniego elementu zwracanej tablicy to 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', ''
Jeśli nawiasy przechwytywania są używane w wyrażeniu Regex.Split , dowolny 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 nawiasów przechwytywania, zachowanie tej metody zależy od wersji .NET Framework. W .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 .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 .NET Framework 1.0 lub 1.1, wyklucza znaki ukośnika. Jeśli jest kompilowany i uruchamiany w .NET Framework 2.0 lub nowszych wersjach, 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, podzieli ciąg na tablicę ciągów jednoznakowych, Split 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 wynosi Regex.InfiniteMatchTimeout, nie zostanie zgłoszony 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ż
Dotyczy
Split(String, String, RegexOptions, TimeSpan)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Dzieli ciąg wejściowy na tablicę podciągów na pozycjach zdefiniowanych przez określony wzorzec wyrażenia regularnego. Dodatkowe parametry określają opcje modyfikujące pasującą 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
Tablica ciągów.
Wyjątki
Wystąpił błąd analizowania wyrażeń regularnych.
input lub pattern to null.
options nie jest prawidłową kombinacją bitów RegexOptions wartości.
-lub-
matchTimeout jest ujemna, zero lub większa niż około 24 dni.
Wystąpił limit czasu. Aby uzyskać więcej informacji na temat limitów czasu, zobacz sekcję Uwagi.
Uwagi
Metody Regex.Split są podobne do String.Split(Char[]) metody, 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 input ciągiem.
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 (Wyrażenia regularne platformy .NET i język wyrażeń regularnych — szybki przewodnik).
Ważne
Skompilowane wyrażenia regularne używane w wywołaniach do metod statycznych Split są automatycznie buforowane. Aby samodzielnie zarządzać okresem istnienia skompilowanych wyrażeń regularnych, użyj metod wystąpienia Split .
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 zwrócona tablica będzie 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 zwróconej tablicy. W poniższym przykładzie użyto wzorca [a-z]+ wyrażenia regularnego, aby podzielić ciąg wejściowy na dowolną wielką lub małą literę alfabetyczną. Ponieważ ciąg zaczyna się i kończy się pasującymi znakami alfabetycznymi, wartość pierwszego i ostatniego elementu zwracanej tablicy to 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 , dowolny 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 nawiasów przechwytywania, zachowanie tej metody zależy od wersji .NET Framework. W .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 .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 .NET Framework 1.0 lub 1.1, wyklucza znaki ukośnika. Jeśli jest kompilowany i uruchamiany w .NET Framework 2.0 lub nowszych wersjach, 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, podzieli ciąg na tablicę ciągów jednoznakowych, Split ponieważ pusty ogranicznik ciągu można znaleźć w każdej lokalizacji.
Parametr matchTimeout określa, jak długo metoda dopasowywania wzorca powinna spróbować znaleźć dopasowanie przed upływem limitu czasu. Ustawienie interwału limitu czasu zapobiega wyrażeniom regularnym, które polegają na nadmiernej wycofywaniu, aby przestać odpowiadać podczas przetwarzania danych wejściowych zawierających niemal dopasowania. Aby uzyskać więcej informacji, zobacz Najlepsze rozwiązania dotyczące wyrażeń regularnych i wycofywania. Jeśli w tym interwale czasu nie znaleziono dopasowania, metoda zgłasza RegexMatchTimeoutException wyjątek. matchTimeout zastępuje dowolną 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ść, taką jak dwie sekundy. Jeśli wyłączysz limity czasu, określając InfiniteMatchTimeoutwartość , 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ładają 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, aby upewnić się, że efektywnie obsługuje dopasowania, niezgodne i zbliżające się dopasowania.
Gdy wzorzec wyrażenia regularnego nie zawiera żadnych elementów języka, które są znane do nadmiernego wycofywania podczas przetwarzania niemal zgodnego.
Zobacz też
Dotyczy
Opinia
Dostępne już wkrótce: W 2024 r. będziemy stopniowo wycofywać zgłoszenia z serwisu GitHub jako mechanizm przesyłania opinii na temat zawartości i zastępować go nowym systemem opinii. Aby uzyskać więcej informacji, sprawdź: https://aka.ms/ContentUserFeedback.
Prześlij i wyświetl opinię dla