Exportieren (0) Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

Regex.Split-Methode (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.

Namespace:  System.Text.RegularExpressions
Assembly:  System (in System.dll)

public string[] Split(
	string input,
	int count,
	int startat
)

Parameter

input
Typ: System.String
Die aufzuteilende Zeichenfolge.
count
Typ: System.Int32
Die maximale Anzahl der Teilungen.
startat
Typ: System.Int32
Die Zeichenposition in der Eingabezeichenfolge, an der mit der Suche begonnen wird.

Rückgabewert

Typ: System.String[]
Ein Array von Zeichenfolgen.

AusnahmeBedingung
ArgumentNullException

input ist null.

ArgumentOutOfRangeException

startat ist kleiner als 0 (null) oder größer als die Länge von input.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Die Regex.Split-Methoden sind die String.Split-Methode vergleichbar, außer dass Regex.Split Teilungen, die die Zeichenfolge mit einem Trennzeichen durch einen regulären Ausdruck anstelle eines Satzes bestimmte Zeichen. Der count-Parameter gibt die maximale Anzahl von untergeordneten Zeichenfolgen an, in die die input-Zeichenfolge aufgeteilt wird, wobei die letzte Zeichenfolge den nicht aufgeteilten Rest der Zeichenfolge enthält. Mit dem count-Wert 0 (null) wird das Standardverhalten bereitgestellt, bei dem so oft wie möglich geteilt wird. Der startat-Parameter definiert den Punkt, an dem die Suche nach dem ersten Trennzeichen beginnt (dies kann verwendet werden, um vorangestellte Leerzeichen zu überspringen).

Wenn ab der Position count+1 keine Übereinstimmungen gefunden werden, gibt die Methode ein Array mit einem Element 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 aneinandergrenzen und die Anzahl der gefundenen Übereinstimmungen mindestens zwei weniger als count ist, wird eine leere Zeichenfolge in das Array eingefügt. Auch wenn eine Übereinstimmung bei startat gefunden wird, die das erste Zeichen in der Zeichenfolge ist, ist das erste Element des zurückgegebenen Arrays eine leere Zeichenfolge. Das heißt, dass aus aneinandergrenzenden Übereinstimmungen resultierende leere Zeichenfolgen gezählt werden, um zu bestimmen, ob die Anzahl der übereinstimmenden untergeordneten Zeichenfolgen gleich count ist. Im folgenden Beispiel wird der reguläre Ausdruck \d+, um die Anfangsposition der ersten Teilzeichenfolge der numerischen Zeichen in einer Zeichenfolge zu suchen, die verwendet und Zeichenfolge dann zu teilen maximal dreimal beginnend an dieser Position. Da das Muster für reguläre Ausdrücke den Anfang der Eingabezeichenfolge übereinstimmt, besteht das zurückgegebene Zeichenfolgenarray einer leeren Zeichenfolge, einer fünf Zeichen Großbuchstaben Buchstabenkette 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'


Wenn in einem regulären Ausdruck umschließende Klammern verwendet werden, wird sämtlicher erfasster Text im Array geteilter Zeichenfolgen eingeschlossen. Bei der Bestimmung, ob die Anzahl der Übereinstimmungen count erreicht hat, werden jedoch keine Arrayelemente gezählt, die erfassten Text enthalten. Das Aufteilen der Zeichenfolge "apple-apricot-plum-pear-pomegranate-pineapple-peach" in die maximale Anzahl von vier untergeordneten Zeichenfolgen ab Zeichen 15 der Zeichenfolge ergibt beispielsweise ein Array mit sieben Elementen, wie im folgenden Code gezeigt.


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 des regulären Ausdrucks jedoch mehrere Sätze von umschließenden Klammern enthält, hängt das Verhalten dieser Methode von der .NET Framework-Version ab. In .NET Framework 1.0 und 1,1 wenn eine Übereinstimmung nicht innerhalb zuerst festgelegt von umschließende Klammern gefunden wird, wird aufgezeichneten Text zu zusätzlicher umschließende Klammern nicht im zurückgegebenen Array enthalten. Ab .NET Framework 2.0, wird der gesamte Text aufgezeichnete auch dem zurückgegebenen Array hinzugefügt. Im folgenden Code werden beispielsweise zwei Sätze umschließender Klammern verwendet, um die einzelnen Wörter einer Zeichenfolge zu extrahieren. Zuerst Satz von umschließende Klammern zeichnet den Bindestrich auf, und der zweite Satz erfasst den senkrechten Balken auf. Wenn der Beispielcode und Ausführung unter .NET Framework 1.0 oder den 1,1 kompiliert wird, wird jedoch die senkrechte Striche aus; wenn er und Ausführung unter .NET Framework 2.0 oder höheren Versionen kompiliert ist, enthält sie ein.


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'


Wenn der reguläre Ausdruck der leeren Zeichenfolge entsprechen kann, teilt Split die Zeichenfolge in ein Array von Zeichenfolgen mit jeweils einem Zeichen auf, da das Trennzeichen für leere Zeichenfolgen an jeder Position gefunden wird. Im folgenden Beispiel wird die Zeichenfolge "characters" in die Anzahl der Elemente aufgeteilt, die in der Eingabezeichenfolge enthalten sind, wobei mit dem Zeichen "a" begonnen wird. Da die NULL-Zeichenfolge dem Ende der Eingabezeichenfolge entspricht, 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}


Die RegexMatchTimeoutException-Ausnahme wird ausgelöst, wenn die Ausführungszeit des Teilungsvorgangs das Timeoutintervall überschreitet, das vom Regex.Regex(String, RegexOptions, TimeSpan) konstruktor angegeben wird. Wenn Sie kein Timeoutintervall festlegen, wenn Sie den Konstruktor aufrufen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeoutwert übersteigt, der für die Anwendungsdomäne erstellt wird, in der das Regex-Objekt erstellt wird. Wenn kein Timeout im Konstruktoraufruf Regex oder Eigenschaften der Anwendungsdomäne definiert wird oder wenn der Timeoutwert Regex.InfiniteMatchTimeout ist, wird keine Ausnahme ausgelöst

.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

.NET für Windows Phone-Apps

Unterstützt in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft