Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Regex.Split-Methode: (String, Int32, Int32)

 

Veröffentlicht: Oktober 2016

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
Type: System.String

Die aufzuteilende Zeichenfolge.

count
Type: System.Int32

Die maximale Anzahl der Teilungen.

startat
Type: System.Int32

Die Zeichenposition in der Eingabezeichenfolge, an der mit der Suche begonnen wird.

Rückgabewert

Type: System.String[]

Ein Array von Zeichenfolgen.

Exception Condition
ArgumentNullException

input ist null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Die Regex.Split Methoden ähneln die String.Split -Methode, außer dass Regex.Split teilt die Zeichenfolge an einem Trennzeichen, das durch einen regulären Ausdruck anstelle einer Reihe von Zeichen festgelegt. Die count Parameter gibt die maximale Anzahl von Teilzeichenfolgen, in dem die input aufteilen Zeichenfolge; die letzte Zeichenfolge den nicht aufgeteilten Rest der Zeichenfolge enthält. Ein count Wert von 0 (null) ist das Standardverhalten so oft wie möglich geteilt. Die startat -Parameter definiert den Punkt, an dem die Suche nach dem ersten Trennzeichen beginnt (Dies kann verwendet werden um führende Leerzeichen zu überspringen).

Wenn keine Übereinstimmungen gefunden werden, aus der count+ 1 position in der Zeichenfolge, die Methode gibt ein Array von einem Element, enthält die input Zeichenfolge. Wenn eine oder mehrere Übereinstimmungen gefunden werden, enthält das erste Element des zurückgegebenen Arrays den ersten Teil der Zeichenfolge mit dem ersten Zeichen bis zu einem Zeichen vor der Übereinstimmung.

Wenn mehrere Übereinstimmungen nebeneinander und die Anzahl der gefundenen Übereinstimmungen mindestens zwei ist weniger als count, wird eine leere Zeichenfolge in das Array eingefügt. Auf ähnliche Weise, wenn eine Übereinstimmung, am gefunden wird startat, das das erste Zeichen in der Zeichenfolge, das erste Element des zurückgegebenen Arrays ist eine leere Zeichenfolge. Also leere Zeichenfolgen, die aus angrenzenden entspricht im gezählt werden, bestimmen, ob die Anzahl von Teilzeichenfolgen gleich abgeglichen count. Im folgenden Beispiel wird der reguläre Ausdruck \d+ wird verwendet, um die Anfangsposition des ersten Teilzeichenfolge von numerischen Zeichen in einer Zeichenfolge zu suchen und dann die Zeichenfolge zu teilen, maximal drei Mal beginnend an dieser Position. Da Muster für reguläre Ausdrücke den Anfang der Eingabezeichenfolge entspricht, besteht das Array der zurückgegebenen Zeichenfolge eine leere Zeichenfolge, eine alphabetische Zeichenfolge fünf Zeichen und der 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 umschließenden Klammern in einem regulären Ausdruck verwendet werden, ist im Array der geteilten Zeichenfolgen erfasster Text enthalten. Allerdings alle Arrayelemente, die erfassten Text enthalten, werden nicht gezählt bestimmen, ob die Anzahl der Übereinstimmungen erreicht hat count. Teilen Sie z. B. die Zeichenfolge ""Peach"in maximal vier Teilzeichenfolgen beginnend mit 15 Zeichen, in der Zeichenfolge 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 eines regulären Ausdrucks mehrere Sätze von umschließenden Klammern enthält, hängt das Verhalten dieser Methode jedoch auf die Version von .NET Framework. Wenn innerhalb der ersten schließenden Klammern, keine Übereinstimmung gefunden wird, ist in .NET Framework 1.0 und 1.1 nicht erfasste Text zusätzliche umschließenden Klammern im zurückgegebenen Array enthalten. Ab .NET Framework 2.0 wird sämtlicher erfasster Text auch das zurückgegebene Array hinzugefügt. Der folgende Code verwendet z. B. zwei Sätze von schließenden Klammern, um die einzelnen Wörter in einer Zeichenfolge zu extrahieren. Der erste Satz von schließenden Klammern erfasst den Bindestrich, und der zweite Satz den senkrechten Strich erfasst. Wenn der Beispielcode Kompilierung und Ausführung unter .NET Framework 1.0 oder 1.1, schließt Sie die vertikale Balken Zeichen. Wenn die Kompilierung und unter den .NET Framework 2.0 oder höher ausgeführt werden, werden diese eingeschlossen.

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 leere Zeichenfolge entsprechen kann Split teilen die Zeichenfolge in ein Array von Zeichenfolgen mit einem Zeichen, da das Trennzeichen für leere Zeichenfolgen an jeder Position gefunden werden kann. Im folgenden Beispiel wird die Zeichenfolge "Zeichen" in die Anzahl der Elemente, wie die Eingabezeichenfolge enthält, beginnend mit dem Zeichen, "a". Da die null-Zeichenfolge das 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 Split-Vorgangs des angegebenen Timeoutintervalls überschreitet die Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor. Wenn Sie ein Timeoutintervall nicht festlegen, wenn Sie den Konstruktor aufrufen, wird die Ausnahme ausgelöst, wenn der Vorgang alle für die Anwendungsdomäne eingerichtet, in dem Timeoutwert überschreitet die Regex Objekt erstellt wird. Wenn kein Timeout, in definiert ist der Regex Konstruktoraufruf oder in Eigenschaften der Anwendungsdomäne, oder wenn der Timeoutwert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: