Regex.Split Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Teilt eine Eingabezeichenfolge an den Positionen in ein Array von Teilzeichenfolgen auf, die durch eine Übereinstimmung mit einem regulären Ausdruck definiert werden.
Überlädt
| Split(String) |
Teilt die angegebene Eingabezeichenfolge an den Positionen in ein Array von Teilzeichenfolgen auf, die durch ein im Regex-Konstruktor angegebenes Muster für einen regulären Ausdruck definiert werden. |
| Split(String, Int32) |
Teilt die angegebene Eingabezeichenfolge höchstens die angegebene Anzahl von Malen an den Positionen in ein Array von Teilzeichenfolgenketten auf, die durch einen im Regex-Konstruktor angegebenen regulären Ausdruck definiert werden. |
| Split(String, String) |
Teilt eine Eingabezeichenfolge an den durch ein reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf. |
| Split(String, Int32, Int32) |
Teilt die angegebene Eingabezeichenfolge höchstens die angegebene Anzahl von Malen an den Positionen in ein Array von Teilzeichenfolgenketten auf, die durch einen im Regex-Konstruktor angegebenen regulären Ausdruck definiert werden. Die Suche nach dem Muster des regulären Ausdrucks beginnt bei einer angegebenen Zeichenposition in der Eingabezeichenfolge. |
| Split(String, String, RegexOptions) |
Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert. |
| Split(String, String, RegexOptions, TimeSpan) |
Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird. |
Split(String)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Teilt die angegebene Eingabezeichenfolge an den Positionen in ein Array von Teilzeichenfolgen auf, die durch ein im Regex-Konstruktor angegebenes Muster für einen regulären Ausdruck definiert werden.
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()Parameter
- input
- String
Die zu teilende Zeichenfolge.
Gibt zurück
Ein Array der Zeichenfolgen.
Ausnahmen
input ist null.
Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.
Hinweise
Die Regex.Split Methoden ähneln der String.Split(Char[]) -Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen aufgeteilt wird, das von einem regulären Ausdruck anstelle einer Reihe von Zeichen bestimmt wird. Die Zeichenfolge wird so oft wie möglich geteilt. Wenn kein Trennzeichen gefunden wird, enthält der Rückgabewert ein Element, dessen Wert die ursprüngliche Eingabezeichenfolge ist.
Wenn mehrere Übereinstimmungen nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt. Das Aufteilen einer Zeichenfolge auf einen einzelnen Bindestrich führt beispielsweise dazu, dass das zurückgegebene Array eine leere Zeichenfolge an der Position enthält, an der zwei benachbarte Bindestriche gefunden werden, wie der folgende Code zeigt.
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'
Wenn am Anfang oder am Ende der Eingabezeichenfolge eine Übereinstimmung gefunden wird, wird am Anfang oder Am Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingeschlossen. Im folgenden Beispiel wird das Muster \d+ für reguläre Ausdrücke verwendet, um eine Eingabezeichenfolge in numerische Zeichen aufzuteilen. Da die Zeichenfolge mit übereinstimmenden numerischen Zeichen beginnt und endet, ist String.Emptyder Wert des ersten und letzten Elements des zurückgegebenen Arrays .
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', ''
Wenn erfassungsklammern in einem Regex.Split Ausdruck verwendet werden, wird der erfasste Text im resultierenden Zeichenfolgenarray enthalten. Wenn Sie beispielsweise die Zeichenfolge "plum-pear" auf einen Bindestrich in Erfassungsklammern aufteilen, enthält das zurückgegebene Array ein Zeichenfolgenelement, das den Bindestrich enthält.
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'
Wenn das Muster für reguläre Ausdrücke jedoch mehrere Sätze von Erfassungsklammern enthält, hängt das Verhalten dieser Methode von der Version des .NET Framework ab. Wenn in den .NET Framework 1.0 und 1.1 keine Übereinstimmung innerhalb der ersten Gruppe von Erfassungsklammern gefunden wird, ist erfasster Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab dem .NET Framework 2.0 wird auch der gesamte erfasste Text dem zurückgegebenen Array hinzugefügt. Der folgende Code verwendet beispielsweise zwei Sätze von Erfassungsklammern, um die Elemente eines Datums, einschließlich der Datumstrennzeichen, aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich, und der zweite Satz erfasst den Schrägstrich. Wenn der Beispielcode kompiliert und unter dem .NET Framework 1.0 oder 1.1 ausgeführt wird, werden die Schrägstriche ausgeschlossen. Wenn er kompiliert und unter der .NET Framework 2.0 oder höher ausgeführt wird, enthält er diese.
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'
Wenn der reguläre Ausdruck mit der leeren Zeichenfolge übereinstimmen kann, Split(String) wird die Zeichenfolge in ein Array von einstelligen Zeichenfolgen aufgeteilt, da das leere Zeichenfolgentrennzeichen an jeder Position gefunden werden kann. Beispiel:
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, }
Beachten Sie, dass das zurückgegebene Array auch eine leere Zeichenfolge am Anfang und Ende des Arrays enthält.
Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Splitvorgangs das vom Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor angegebene Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der das Regex Objekt erstellt wird. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert lautet Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.
Weitere Informationen
Gilt für:
Split(String, Int32)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Teilt die angegebene Eingabezeichenfolge höchstens die angegebene Anzahl von Malen an den Positionen in ein Array von Teilzeichenfolgenketten auf, die durch einen im Regex-Konstruktor angegebenen regulären Ausdruck definiert werden.
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()Parameter
- input
- String
Die aufzuteilende Zeichenfolge.
- count
- Int32
Die maximale Anzahl der Teilungen.
Gibt zurück
Ein Array der Zeichenfolgen.
Ausnahmen
input ist null.
Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.
Hinweise
Die Regex.Split Methoden ähneln der String.Split -Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen aufgeteilt wird, das von einem regulären Ausdruck anstelle einer Reihe von Zeichen bestimmt wird. Der count Parameter gibt die maximale Anzahl von Teilzeichenfolgen an, in die die input Zeichenfolge aufgeteilt werden kann. Die letzte Zeichenfolge enthält den nicht teiligen Rest der Zeichenfolge. Ein count Wert von 0 stellt das Standardverhalten bereit, so oft wie möglich aufzuteilen.
Wenn mehrere Übereinstimmungen nebeneinander liegen oder eine Übereinstimmung am Anfang oder Ende von inputgefunden wird und die Anzahl der gefundenen Übereinstimmungen mindestens zwei kleiner als countist, wird eine leere Zeichenfolge in das Array eingefügt. Das heißt, leere Zeichenfolgen, die sich aus benachbarten Übereinstimmungen oder aus Übereinstimmungen am Anfang oder Ende der Eingabezeichenfolge ergeben, werden gezählt, um zu bestimmen, ob die Anzahl der übereinstimmenden Teilzeichenfolgen gleich ist count. Im folgenden Beispiel wird der reguläre Ausdruck /d+ verwendet, um eine Eingabezeichenfolge, die eine oder mehrere Dezimalstellen enthält, in maximal drei Teilzeichenfolgen aufzuteilen. Da der Anfang der Eingabezeichenfolge mit dem Muster des regulären Ausdrucks übereinstimmt, enthält String.Emptydas erste Arrayelement , das zweite enthält den ersten Satz alphabetischer Zeichen in der Eingabezeichenfolge, und der dritte enthält den Rest der Zeichenfolge, die auf die dritte Übereinstimmung folgt.
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'
Wenn erfassungsklammern in einem regulären Ausdruck verwendet werden, wird der erfasste Text in das Array geteilter Zeichenfolgen eingeschlossen. Alle Arrayelemente, die erfassten Text enthalten, werden jedoch nicht gezählt, um zu bestimmen, ob die Anzahl der Übereinstimmungen erreicht countwurde. Das Aufteilen der Zeichenfolge "apple-apricot-plum-pear-banana" in maximal vier Teilzeichenfolgen führt beispielsweise zu einem Array mit sieben Elementen, wie der folgende Code zeigt.
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'
Wenn das Muster für reguläre Ausdrücke jedoch mehrere Sätze von Erfassungsklammern enthält, hängt das Verhalten dieser Methode von der Version des .NET Framework ab. In den .NET Framework 1.0 und 1.1 ist nur erfasster Text aus dem ersten Satz von Erfassungsklammern im zurückgegebenen Array enthalten. Ab dem .NET Framework 2.0 wird der gesamte erfasste Text dem zurückgegebenen Array hinzugefügt. Elemente im zurückgegebenen Array, die erfassten Text enthalten, werden jedoch nicht gezählt, um zu bestimmen, ob die Anzahl der übereinstimmenden Teilzeichenfolgen gleich ist count. Im folgenden Code verwendet ein regulärer Ausdruck beispielsweise zwei Sätze von Erfassungsklammern, um die Elemente eines Datums aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich, und der zweite Satz erfasst den Schrägstrich. Der Aufruf der Split(String, Int32) -Methode gibt dann maximal zwei Elemente im zurückgegebenen Array an. Wenn der Beispielcode kompiliert und unter dem .NET Framework 1.0 oder 1.1 ausgeführt wird, gibt die Methode ein Zeichenfolgenarray mit zwei Elementen zurück. Wenn sie kompiliert und unter der .NET Framework 2.0 oder höher ausgeführt wird, gibt die Methode ein Zeichenfolgenarray mit drei Elementen zurück.
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'
Wenn der reguläre Ausdruck mit der leeren Zeichenfolge übereinstimmen kann, Split(String, Int32) wird die Zeichenfolge in ein Array von einstelligen Zeichenfolgen aufgeteilt, da das leere Zeichenfolgentrennzeichen an jeder Position gefunden werden kann. Im folgenden Beispiel wird die Zeichenfolge "Zeichen" in so viele Elemente unterteilt, wie in der Eingabezeichenfolge vorhanden sind. Da die NULL-Zeichenfolge mit dem Anfang der Eingabezeichenfolge übereinstimmt, wird am Anfang des zurückgegebenen Arrays eine NULL-Zeichenfolge eingefügt. Dadurch besteht das zehnte Element aus den beiden Zeichen am Ende der Eingabezeichenfolge.
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}
Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Splitvorgangs das vom Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor angegebene Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der das Regex Objekt erstellt wird. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert lautet Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.
Weitere Informationen
Gilt für:
Split(String, String)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Teilt eine Eingabezeichenfolge an den durch ein reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.
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()Parameter
- input
- String
Die zu teilende Zeichenfolge.
- pattern
- String
Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.
Gibt zurück
Ein Array der Zeichenfolgen.
Ausnahmen
Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.
input oder pattern ist null.
Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.
Hinweise
Die Regex.Split Methoden ähneln der String.Split -Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen aufgeteilt wird, das von einem regulären Ausdruck anstelle einer Reihe von Zeichen bestimmt wird. Die input Zeichenfolge wird so oft wie möglich geteilt. Wenn pattern in der input Zeichenfolge nicht gefunden wird, enthält der Rückgabewert ein Element, dessen Wert die ursprüngliche input Zeichenfolge ist.
Der pattern Parameter besteht aus Elementen der Regulären Ausdruckssprache, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Schnellreferenz.
Wichtig
Kompilierte reguläre Ausdrücke, die in Aufrufen statischer Split Methoden verwendet werden, werden automatisch zwischengespeichert. Verwenden Sie die Methoden instanceSplit, um die Lebensdauer von kompilierten regulären Ausdrücken selbst zu verwalten.
Wenn mehrere Übereinstimmungen nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt. Das Aufteilen einer Zeichenfolge auf einen einzelnen Bindestrich führt beispielsweise dazu, dass das zurückgegebene Array eine leere Zeichenfolge an der Position enthält, an der zwei benachbarte Bindestriche gefunden werden, wie der folgende Code zeigt.
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'
Wenn am Anfang oder am Ende der Eingabezeichenfolge eine Übereinstimmung gefunden wird, wird am Anfang oder Am Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingeschlossen. Im folgenden Beispiel wird das Muster \d+ für reguläre Ausdrücke verwendet, um eine Eingabezeichenfolge in numerische Zeichen aufzuteilen. Da die Zeichenfolge mit übereinstimmenden numerischen Zeichen beginnt und endet, ist String.Emptyder Wert des ersten und letzten Elements des zurückgegebenen Arrays .
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', ''
Wenn erfassungsklammern in einem Regex.Split Ausdruck verwendet werden, wird der erfasste Text im resultierenden Zeichenfolgenarray enthalten. Wenn Sie beispielsweise die Zeichenfolge "plum-pear" auf einen Bindestrich in Erfassungsklammern aufteilen, enthält das zurückgegebene Array ein Zeichenfolgenelement, das den Bindestrich enthält.
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'
Wenn das Muster für reguläre Ausdrücke jedoch mehrere Sätze von Erfassungsklammern enthält, hängt das Verhalten dieser Methode von der Version des .NET Framework ab. Wenn in den .NET Framework 1.0 und 1.1 keine Übereinstimmung innerhalb der ersten Gruppe von Erfassungsklammern gefunden wird, ist erfasster Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab dem .NET Framework 2.0 wird auch der gesamte erfasste Text dem zurückgegebenen Array hinzugefügt. Der folgende Code verwendet beispielsweise zwei Sätze von Erfassungsklammern, um die Elemente eines Datums, einschließlich der Datumstrennzeichen, aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich, und der zweite Satz erfasst den Schrägstrich. Wenn der Beispielcode kompiliert und unter dem .NET Framework 1.0 oder 1.1 ausgeführt wird, werden die Schrägstriche ausgeschlossen. Wenn er kompiliert und unter der .NET Framework 2.0 oder höher ausgeführt wird, enthält er diese.
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'
Wenn der reguläre Ausdruck mit der leeren Zeichenfolge übereinstimmen kann, Split wird die Zeichenfolge in ein Array von einstelligen Zeichenfolgen aufgeteilt, da das leere Zeichenfolgentrennzeichen an jeder Position gefunden werden kann. Beispiel:
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', ''}
Beachten Sie, dass das zurückgegebene Array auch eine leere Zeichenfolge am Anfang und Ende des Arrays enthält.
Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Splitvorgangs das timeout-Intervall überschreitet, das für die Anwendungsdomäne angegeben ist, in der die Methode aufgerufen wird. Wenn in den Eigenschaften der Anwendungsdomäne kein Timeout definiert ist oder wenn der Timeoutwert lautet Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.
Hinweise für Aufrufer
Bei dieser Methode tritt ein Timeout nach einem Intervall auf, das dem Standard-Timeoutwert der Anwendungsdomäne entspricht, in der die Methode aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der verhindert, dass die Methode ein Timeout ausgibt. Die empfohlene statische Methode zum Aufteilen von Text in einer Musterüberstimmung ist Split(String, String, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall festlegen können.
Weitere Informationen
Gilt für:
Split(String, Int32, Int32)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Teilt die angegebene Eingabezeichenfolge höchstens die angegebene Anzahl von Malen an den Positionen in ein Array von Teilzeichenfolgenketten auf, die durch einen im Regex-Konstruktor angegebenen regulären Ausdruck definiert werden. Die Suche nach dem Muster des regulären Ausdrucks beginnt bei einer angegebenen Zeichenposition in der Eingabezeichenfolge.
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()Parameter
- input
- String
Die aufzuteilende Zeichenfolge.
- count
- Int32
Die maximale Anzahl der Teilungen.
- startat
- Int32
Die Zeichenposition in der Eingabezeichenfolge, an der mit der Suche begonnen wird.
Gibt zurück
Ein Array der Zeichenfolgen.
Ausnahmen
input ist null.
startat ist kleiner als 0 (null) oder größer als die Länge von input.
Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.
Hinweise
Die Regex.Split Methoden ähneln der String.Split -Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen aufgeteilt wird, das von einem regulären Ausdruck anstelle einer Reihe von Zeichen bestimmt wird. Der count -Parameter gibt die maximale Anzahl von Teilzeichenfolgen an, in die die input Zeichenfolge aufgeteilt wird. Die letzte Zeichenfolge enthält den nicht teiligen Rest der Zeichenfolge. Ein count Wert von 0 stellt das Standardverhalten bereit, so oft wie möglich aufzuteilen. Der startat Parameter definiert den Punkt, an dem die Suche nach dem ersten Trennzeichen beginnt (dies kann zum Überspringen des führenden Leerraums verwendet werden).
Weitere Informationen zu startatfinden Sie im Abschnitt Hinweise von Match(String, Int32).
Wenn von der +1-Position in der countZeichenfolge keine Übereinstimmungen gefunden werden, gibt die Methode ein Einelementarray zurück, das die input Zeichenfolge enthält. Wenn eine oder mehrere Übereinstimmungen gefunden werden, enthält das erste Element des zurückgegebenen Arrays den ersten Teil der Zeichenfolge vom ersten Zeichen bis zu einem Zeichen vor der Übereinstimmung.
Wenn mehrere Übereinstimmungen nebeneinander liegen und die Anzahl der gefundenen Übereinstimmungen mindestens zwei kleiner als countist, wird eine leere Zeichenfolge in das Array eingefügt. Wenn eine Übereinstimmung unter startatgefunden wird, die das erste Zeichen in der Zeichenfolge ist, ist das erste Element des zurückgegebenen Arrays eine leere Zeichenfolge. Das heißt, leere Zeichenfolgen, die sich aus benachbarten Übereinstimmungen ergeben, werden gezählt, um zu bestimmen, ob die Anzahl der übereinstimmenden Teilzeichenfolgen gleich ist count. Im folgenden Beispiel wird der reguläre Ausdruck \d+ verwendet, um die Startposition der ersten Teilzeichenfolge numerischer Zeichen in einer Zeichenfolge zu ermitteln und die Zeichenfolge dann maximal dreimal zu teilen, beginnend an dieser Position. Da das Muster des regulären Ausdrucks mit dem Anfang der Eingabezeichenfolge übereinstimmt, besteht das zurückgegebene Zeichenfolgenarray aus einer leeren Zeichenfolge, einer fünfstelligen alphabetischen Zeichenfolge und dem Rest der Zeichenfolge.
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'
Wenn erfassungsklammern in einem regulären Ausdruck verwendet werden, wird der erfasste Text in das Array geteilter Zeichenfolgen eingeschlossen. Alle Arrayelemente, die erfassten Text enthalten, werden jedoch nicht gezählt, um zu bestimmen, ob die Anzahl der Übereinstimmungen erreicht countwurde. Wenn Sie beispielsweise die Zeichenfolge "apple-apricot-plum-pear-pomegranate-pineapple-peach" in maximal vier Teilzeichenfolgen teilen, die mit Zeichen 15 in der Zeichenfolge beginnen, ergibt sich ein Array mit sieben Elementen, wie der folgende Code zeigt.
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'
Wenn das Muster für reguläre Ausdrücke jedoch mehrere Sätze von Erfassungsklammern enthält, hängt das Verhalten dieser Methode von der Version des .NET Framework ab. Wenn in .NET Framework 1.0 und 1.1 keine Übereinstimmung innerhalb der ersten Gruppe von Erfassungsklammern gefunden wird, ist erfasster Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab dem .NET Framework 2.0 wird auch der gesamte erfasste Text dem zurückgegebenen Array hinzugefügt. Der folgende Code verwendet beispielsweise zwei Sätze von Erfassungsklammern, um die einzelnen Wörter in einer Zeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich, und der zweite Satz erfasst den vertikalen Balken. Wenn der Beispielcode kompiliert und unter dem .NET Framework 1.0 oder 1.1 ausgeführt wird, werden die vertikalen Balkenzeichen ausgeschlossen. Wenn er kompiliert und unter der .NET Framework 2.0 oder höher ausgeführt wird, enthält er diese.
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'
Wenn der reguläre Ausdruck mit der leeren Zeichenfolge übereinstimmen kann, Split wird die Zeichenfolge in ein Array von einstelligen Zeichenfolgen aufgeteilt, da das leere Zeichenfolgentrennzeichen an jeder Position gefunden werden kann. Im folgenden Beispiel wird die Zeichenfolge "zeichen" in so viele Elemente unterteilt, wie die Eingabezeichenfolge enthält, beginnend mit dem Zeichen "a". Da die NULL-Zeichenfolge mit dem Ende der Eingabezeichenfolge übereinstimmt, wird am Ende des zurückgegebenen Arrays eine NULL-Zeichenfolge eingefügt.
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}
Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Splitvorgangs das vom Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor angegebene Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der das Regex Objekt erstellt wird. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert lautet Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.
Weitere Informationen
Gilt für:
Split(String, String, RegexOptions)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.
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()Parameter
- input
- String
Die zu teilende Zeichenfolge.
- pattern
- String
Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.
- options
- RegexOptions
Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.
Gibt zurück
Ein Array der Zeichenfolgen.
Ausnahmen
Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.
input oder pattern ist null.
options ist keine gültige bitweise Kombination von RegexOptions-Werten.
Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.
Hinweise
Die Regex.Split Methoden ähneln der String.Split(Char[]) -Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen aufgeteilt wird, das von einem regulären Ausdruck anstelle einer Reihe von Zeichen bestimmt wird. Die Zeichenfolge wird so oft wie möglich geteilt. Wenn kein Trennzeichen gefunden wird, enthält der Rückgabewert ein Element, dessen Wert die ursprüngliche input Zeichenfolge ist.
Der pattern Parameter besteht aus Elementen der Regulären Ausdruckssprache, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Schnellreferenz.
Wichtig
Kompilierte reguläre Ausdrücke, die in Aufrufen statischer Split Methoden verwendet werden, werden automatisch zwischengespeichert. Verwenden Sie die Methoden instanceSplit, um die Lebensdauer von kompilierten regulären Ausdrücken selbst zu verwalten.
Wenn mehrere Übereinstimmungen nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt. Wenn Sie beispielsweise eine Zeichenfolge auf einen einzelnen Bindestrich aufteilen, enthält das zurückgegebene Array eine leere Zeichenfolge an der Position, an der zwei benachbarte Bindestriche gefunden werden.
Wenn am Anfang oder am Ende der Eingabezeichenfolge eine Übereinstimmung gefunden wird, wird am Anfang oder Am Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingeschlossen. Im folgenden Beispiel wird das Muster [a-z]+ für reguläre Ausdrücke verwendet, um eine Eingabezeichenfolge in groß- oder kleinbuchstaben alphabetische Zeichen aufzuteilen. Da die Zeichenfolge mit übereinstimmenden alphabetischen Zeichen beginnt und endet, ist String.Emptyder Wert des ersten und letzten Elements des zurückgegebenen Arrays .
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', ''
Wenn erfassungsklammern in einem Regex.Split Ausdruck verwendet werden, wird der erfasste Text im resultierenden Zeichenfolgenarray enthalten. Wenn Sie beispielsweise die Zeichenfolge "plum-pear" auf einen Bindestrich in Erfassungsklammern aufteilen, enthält das zurückgegebene Array ein Zeichenfolgenelement, das den Bindestrich enthält.
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'
Wenn das Muster für reguläre Ausdrücke jedoch mehrere Sätze von Erfassungsklammern enthält, hängt das Verhalten dieser Methode von der Version des .NET Framework ab. Wenn in den .NET Framework 1.0 und 1.1 keine Übereinstimmung innerhalb der ersten Gruppe von Erfassungsklammern gefunden wird, ist erfasster Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab dem .NET Framework 2.0 wird auch der gesamte erfasste Text dem zurückgegebenen Array hinzugefügt. Der folgende Code verwendet beispielsweise zwei Sätze von Erfassungsklammern, um die Elemente eines Datums, einschließlich der Datumstrennzeichen, aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich, und der zweite Satz erfasst den Schrägstrich. Wenn der Beispielcode kompiliert und unter dem .NET Framework 1.0 oder 1.1 ausgeführt wird, werden die Schrägstriche ausgeschlossen. Wenn er kompiliert und unter der .NET Framework 2.0 oder höher ausgeführt wird, enthält er diese.
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'
Wenn der reguläre Ausdruck mit der leeren Zeichenfolge übereinstimmen kann, Split wird die Zeichenfolge in ein Array von einstelligen Zeichenfolgen aufgeteilt, da das leere Zeichenfolgentrennzeichen an jeder Position gefunden werden kann.
Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Splitvorgangs das timeout-Intervall überschreitet, das für die Anwendungsdomäne angegeben ist, in der die Methode aufgerufen wird. Wenn in den Eigenschaften der Anwendungsdomäne kein Timeout definiert ist oder wenn der Timeoutwert lautet Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.
Hinweise für Aufrufer
Bei dieser Methode tritt ein Timeout nach einem Intervall auf, das dem Standard-Timeoutwert der Anwendungsdomäne entspricht, in der die Methode aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der verhindert, dass die Methode ein Timeout ausgibt. Die empfohlene statische Methode zum Aufteilen von Text in einer Musterüberstimmung ist Split(String, String, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall festlegen können.
Weitere Informationen
Gilt für:
Split(String, String, RegexOptions, TimeSpan)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.
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()Parameter
- input
- String
Die zu teilende Zeichenfolge.
- pattern
- String
Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.
- options
- RegexOptions
Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.
- matchTimeout
- TimeSpan
Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte.
Gibt zurück
Ein Zeichenfolgenarray.
Ausnahmen
Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.
input oder pattern ist null.
options ist keine gültige bitweise Kombination von RegexOptions-Werten.
- oder -
matchTimeout ist negativ, null oder größer als ca. 24 Tage.
Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.
Hinweise
Die Regex.Split Methoden ähneln der String.Split(Char[]) -Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen aufgeteilt wird, das von einem regulären Ausdruck anstelle einer Reihe von Zeichen bestimmt wird. Die Zeichenfolge wird so oft wie möglich geteilt. Wenn kein Trennzeichen gefunden wird, enthält der Rückgabewert ein Element, dessen Wert die ursprüngliche input Zeichenfolge ist.
Der pattern Parameter besteht aus Elementen der Regulären Ausdruckssprache, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Schnellreferenz.
Wichtig
Kompilierte reguläre Ausdrücke, die in Aufrufen statischer Split Methoden verwendet werden, werden automatisch zwischengespeichert. Verwenden Sie die Methoden instanceSplit, um die Lebensdauer von kompilierten regulären Ausdrücken selbst zu verwalten.
Wenn mehrere Übereinstimmungen nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt. Wenn Sie beispielsweise eine Zeichenfolge auf einen einzelnen Bindestrich aufteilen, enthält das zurückgegebene Array eine leere Zeichenfolge an der Position, an der zwei benachbarte Bindestriche gefunden werden.
Wenn am Anfang oder am Ende der Eingabezeichenfolge eine Übereinstimmung gefunden wird, wird am Anfang oder Am Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingeschlossen. Im folgenden Beispiel wird das Muster [a-z]+ für reguläre Ausdrücke verwendet, um eine Eingabezeichenfolge in groß- oder kleinbuchstaben alphabetische Zeichen aufzuteilen. Da die Zeichenfolge mit übereinstimmenden alphabetischen Zeichen beginnt und endet, ist String.Emptyder Wert des ersten und letzten Elements des zurückgegebenen Arrays .
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', ''
Wenn erfassungsklammern in einem Regex.Split Ausdruck verwendet werden, wird der erfasste Text im resultierenden Zeichenfolgenarray enthalten. Wenn Sie beispielsweise die Zeichenfolge "plum-pear" auf einen Bindestrich in Erfassungsklammern aufteilen, enthält das zurückgegebene Array ein Zeichenfolgenelement, das den Bindestrich enthält.
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'
Wenn das Muster für reguläre Ausdrücke jedoch mehrere Sätze von Erfassungsklammern enthält, hängt das Verhalten dieser Methode von der Version des .NET Framework ab. Wenn in den .NET Framework 1.0 und 1.1 keine Übereinstimmung innerhalb der ersten Gruppe von Erfassungsklammern gefunden wird, ist erfasster Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab dem .NET Framework 2.0 wird auch der gesamte erfasste Text dem zurückgegebenen Array hinzugefügt. Der folgende Code verwendet beispielsweise zwei Sätze von Erfassungsklammern, um die Elemente eines Datums, einschließlich der Datumstrennzeichen, aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich, und der zweite Satz erfasst den Schrägstrich. Wenn der Beispielcode kompiliert und unter dem .NET Framework 1.0 oder 1.1 ausgeführt wird, werden die Schrägstriche ausgeschlossen. Wenn er kompiliert und unter der .NET Framework 2.0 oder höher ausgeführt wird, enthält er diese.
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'
Wenn der reguläre Ausdruck mit der leeren Zeichenfolge übereinstimmen kann, Split wird die Zeichenfolge in ein Array von einstelligen Zeichenfolgen aufgeteilt, da das leere Zeichenfolgentrennzeichen an jeder Position gefunden werden kann.
Der matchTimeout -Parameter gibt an, wie lange eine Musterabgleichsmethode versuchen soll, eine Übereinstimmung zu finden, bevor ein Zeitüberschreitung vorliegt. Das Festlegen eines Timeoutintervalls verhindert, dass reguläre Ausdrücke, die auf übermäßiger Rückverfolgung basieren, nicht mehr reagieren, wenn sie Eingaben verarbeiten, die nahezu Übereinstimmungen enthalten. Weitere Informationen finden Sie unter Bewährte Methoden für reguläre Ausdrücke und Backtracking. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Methode eine Ausnahme aus RegexMatchTimeoutException . matchTimeout Überschreibt jeden Standardmäßigen Timeoutwert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.
Hinweise für Aufrufer
Es wird empfohlen, den matchTimeout Parameter auf einen geeigneten Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Timeouts deaktivieren, indem Sie angeben InfiniteMatchTimeout, bietet die Engine für reguläre Ausdrücke eine etwas bessere Leistung. Timeouts sollten sie jedoch nur unter den folgenden Bedingungen deaktivieren:
Wenn die von einem regulären Ausdruck verarbeitete Eingabe von einer bekannten und vertrauenswürdigen Quelle abgeleitet wird oder aus statischem Text besteht. Dies schließt Text aus, der von Benutzern dynamisch eingegeben wurde.
Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass es Übereinstimmungen, Nicht-Übereinstimmungen und Fast-Übereinstimmungen effizient verarbeitet.
Wenn das Muster des regulären Ausdrucks keine Sprachelemente enthält, von denen bekannt ist, dass sie bei der Verarbeitung einer fast übereinstimmung übermäßigen Rückverfolgung verursachen.
Weitere Informationen
Gilt für:
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für