Regex.Split Methode

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()

Parameters

Retouren

Een tekenreeksmatrix.

Uitzonderingen

Opmerkingen

De Regex.Split methoden zijn vergelijkbaar met de String.Split(Char[]) methode, behalve dat Regex.Split de tekenreeks wordt gesplitst op een scheidingsteken dat wordt bepaald door een reguliere expressie in plaats van een set tekens. De tekenreeks wordt zo vaak mogelijk gesplitst. Als er geen scheidingsteken wordt gevonden, bevat de retourwaarde één element waarvan de waarde de oorspronkelijke input tekenreeks is.

De pattern parameter bestaat uit reguliere expressietaalelementen die de tekenreeks symbolisch beschrijven die overeenkomen. Zie .NET Reguliere expressies en Regular Expression Language - Quick Reference voor meer informatie over reguliere expressies.

Als meerdere overeenkomsten naast elkaar staan, wordt een lege tekenreeks ingevoegd in de matrix. Als u bijvoorbeeld een tekenreeks splitst op één afbreekstreepje, zorgt u ervoor dat de geretourneerde matrix een lege tekenreeks opneemt op de positie waar twee aangrenzende afbreekstreepjes worden gevonden.

Als er een overeenkomst wordt gevonden aan het begin of einde van de invoertekenreeks, wordt een lege tekenreeks opgenomen aan het begin of einde van de geretourneerde matrix. In het volgende voorbeeld wordt het patroon reguliere expressie [a-z]+ gebruikt om een invoertekenreeks te splitsen op hoofdletters of kleine letters. Omdat de tekenreeks begint en eindigt met overeenkomende alfabetische tekens, is String.Emptyde waarde van het eerste en laatste element van de geretourneerde matrix.

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

Als haakjes worden vastgelegd in een Regex.Split expressie, wordt alle vastgelegde tekst opgenomen in de resulterende tekenreeksmatrix. Als u bijvoorbeeld de tekenreeks 'plum-pear' splitst op een afbreekstreepje dat tussen haakjes wordt geplaatst, bevat de geretourneerde matrix een tekenreekselement dat het afbreekstreepje bevat.

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'

Wanneer het reguliere expressiepatroon echter meerdere sets met haakjes vastleggen bevat en er geen overeenkomst wordt gevonden in de eerste set haakjes vastleggen, wordt vastgelegde tekst van extra haakjes vastgelegd in de geretourneerde matrix.

Als de reguliere expressie overeenkomt met de lege tekenreeks, Split wordt de tekenreeks gesplitst in een matrix met tekenreeksen met één teken, omdat het lege tekenreeksscheidingsteken op elke locatie kan worden gevonden.

De matchTimeout parameter geeft aan hoe lang een patroonkoppelingsmethode moet proberen een overeenkomst te vinden voordat er een time-out optreedt. Als u een time-outinterval instelt, voorkomt u dat reguliere expressies die afhankelijk zijn van overmatige backtracking niet meer reageren wanneer ze invoer verwerken die bijna overeenkomsten bevat. Zie Aanbevolen procedures voor reguliere expressies en backtracking voor meer informatie. Als er in dat tijdsinterval geen overeenkomst wordt gevonden, genereert de methode een RegexMatchTimeoutException uitzondering. matchTimeout overschrijft een standaardtime-outwaarde die is gedefinieerd voor het toepassingsdomein waarin de methode wordt uitgevoerd.

Notities voor bellers

U wordt aangeraden de matchTimeout parameter in te stellen op een geschikte waarde, zoals twee seconden. Als u time-outs uitschakelt door op te InfiniteMatchTimeoutgeven, biedt de reguliere expressie-engine iets betere prestaties. Schakel echter alleen time-outs uit onder de volgende voorwaarden:

• Wanneer de invoer die door een reguliere expressie wordt verwerkt, wordt afgeleid van een bekende en vertrouwde bron of bestaat uit statische tekst. Dit sluit tekst uit die dynamisch door gebruikers is ingevoerd.

• Wanneer het reguliere expressiepatroon grondig is getest om ervoor te zorgen dat er efficiënt overeenkomsten, niet-overeenkomsten en bijna-overeenkomsten worden verwerkt.

• Wanneer het reguliere expressiepatroon geen taalelementen bevat die bekend zijn dat ze overmatige backtracking veroorzaken bij het verwerken van een bijna-overeenkomst.

Zie ook

• Taalelementen voor reguliere expressies

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()

Parameters

Retouren

Een array van tekenreeksen.

Uitzonderingen

Opmerkingen

De Regex.Split methoden zijn vergelijkbaar met de String.Split(Char[]) methode, behalve dat Regex.Split de tekenreeks wordt gesplitst op een scheidingsteken dat wordt bepaald door een reguliere expressie in plaats van een set tekens. De tekenreeks wordt zo vaak mogelijk gesplitst. Als er geen scheidingsteken wordt gevonden, bevat de retourwaarde één element waarvan de waarde de oorspronkelijke input tekenreeks is.

De pattern parameter bestaat uit reguliere expressietaalelementen die de tekenreeks symbolisch beschrijven die overeenkomen. Zie .NET Reguliere expressies en Regular Expression Language - Quick Reference voor meer informatie over reguliere expressies.

Als meerdere overeenkomsten naast elkaar staan, wordt een lege tekenreeks ingevoegd in de matrix. Als u bijvoorbeeld een tekenreeks splitst op één afbreekstreepje, zorgt u ervoor dat de geretourneerde matrix een lege tekenreeks opneemt op de positie waar twee aangrenzende afbreekstreepjes worden gevonden.

Als er een overeenkomst wordt gevonden aan het begin of einde van de invoertekenreeks, wordt een lege tekenreeks opgenomen aan het begin of einde van de geretourneerde matrix. In het volgende voorbeeld wordt het patroon reguliere expressie [a-z]+ gebruikt om een invoertekenreeks te splitsen op hoofdletters of kleine letters. Omdat de tekenreeks begint en eindigt met overeenkomende alfabetische tekens, is String.Emptyde waarde van het eerste en laatste element van de geretourneerde matrix.

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

Als haakjes worden vastgelegd in een Regex.Split expressie, wordt alle vastgelegde tekst opgenomen in de resulterende tekenreeksmatrix. Als u bijvoorbeeld de tekenreeks 'plum-pear' splitst op een afbreekstreepje dat tussen haakjes wordt geplaatst, bevat de geretourneerde matrix een tekenreekselement dat het afbreekstreepje bevat.

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'

Wanneer het reguliere expressiepatroon echter meerdere sets met haakjes vastleggen bevat en er geen overeenkomst wordt gevonden in de eerste set haakjes vastleggen, wordt vastgelegde tekst van extra haakjes vastgelegd in de geretourneerde matrix.

Als de reguliere expressie overeenkomt met de lege tekenreeks, Split wordt de tekenreeks gesplitst in een matrix met tekenreeksen met één teken, omdat het lege tekenreeksscheidingsteken op elke locatie kan worden gevonden.

De RegexMatchTimeoutException uitzondering wordt gegenereerd als de uitvoeringstijd van de splitsbewerking het time-outinterval overschrijdt dat is opgegeven voor het toepassingsdomein waarin de methode wordt aangeroepen. Als er geen time-out is gedefinieerd in de eigenschappen van het toepassingsdomein of als de time-outwaarde is Regex.InfiniteMatchTimeout, wordt er geen uitzondering gegenereerd.

Notities voor bellers

Deze methode treedt op na een interval dat gelijk is aan de standaardtime-outwaarde van het toepassingsdomein waarin de methode wordt aangeroepen. Als er geen time-outwaarde is gedefinieerd voor het toepassingsdomein, wordt de waarde InfiniteMatchTimeout, waardoor er geen time-out optreedt voor de methode, gebruikt. De aanbevolen statische methode voor het splitsen van tekst in een patroonovereenkomst is Split(String, String, RegexOptions, TimeSpan), waarmee u het time-outinterval kunt instellen.

Zie ook

• Taalelementen voor reguliere expressies

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()

Parameters

Retouren

Een array van tekenreeksen.

Uitzonderingen

Opmerkingen

De Regex.Split methoden zijn vergelijkbaar met de String.Split methode, behalve dat Regex.Split de tekenreeks wordt gesplitst op een scheidingsteken dat wordt bepaald door een reguliere expressie in plaats van een set tekens. De count parameter geeft het maximum aantal subtekenreeksen op waarin de input tekenreeks wordt gesplitst. De laatste tekenreeks bevat de rest van de splitsing van de tekenreeks. Een count waarde van nul biedt het standaardgedrag om zo vaak mogelijk te splitsen. De startat parameter definieert het punt waarop het zoeken naar het eerste scheidingsteken begint (dit kan worden gebruikt voor het overslaan van voorloopspaties).

startatZie de sectie Opmerkingen van Match(String, Int32).

Als er geen overeenkomsten worden gevonden op de countpositie +1 in de tekenreeks, retourneert de methode een matrix met één element die de input tekenreeks bevat. Als een of meer overeenkomsten worden gevonden, bevat het eerste element van de geretourneerde matrix het eerste gedeelte van de tekenreeks van het eerste teken tot één teken vóór de overeenkomst.

Als meerdere overeenkomsten naast elkaar staan en het aantal gevonden overeenkomsten ten minste twee kleiner is dan count, wordt er een lege tekenreeks ingevoegd in de matrix. Als er een overeenkomst wordt gevonden op startat, het eerste teken in de tekenreeks, is het eerste element van de geretourneerde matrix een lege tekenreeks. Dat wil gezegd, lege tekenreeksen die het resultaat zijn van aangrenzende overeenkomsten, worden geteld bij het bepalen of het aantal overeenkomende subtekenreeksen gelijk is countaan . In het volgende voorbeeld wordt de reguliere expressie \d+ gebruikt om de beginpositie te vinden van de eerste subtekenreeks van numerieke tekens in een tekenreeks en vervolgens om de tekenreeks maximaal drie keer te splitsen vanaf die positie. Omdat het reguliere expressiepatroon overeenkomt met het begin van de invoertekenreeks, bestaat de geretourneerde tekenreeksmatrix uit een lege tekenreeks, een alfabetische tekenreeks met vijf tekens en de rest van de tekenreeks.

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'

Als haakjes worden vastgelegd in een reguliere expressie, wordt elke vastgelegde tekst opgenomen in de matrix met gesplitste tekenreeksen. Alle matrixelementen die vastgelegde tekst bevatten, worden echter niet meegeteld bij het bepalen of het aantal overeenkomsten is bereikt count. Als u bijvoorbeeld de tekenreeks "apple-abricot-plum-pear-pomegranate-ananas-perzik" splitst in maximaal vier subtekenreeksen die beginnen bij teken 15 in de tekenreeks, resulteert dit in een matrix met zeven elementen, zoals in de volgende code wordt weergegeven.

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'

Wanneer het reguliere expressiepatroon echter meerdere sets met haakjes vastleggen bevat en er geen overeenkomst wordt gevonden in de eerste set haakjes vastleggen, wordt vastgelegde tekst van extra haakjes opgenomen in de geretourneerde matrix.

Als de reguliere expressie overeenkomt met de lege tekenreeks, Split splitst u de tekenreeks in een matrix met tekenreeksen met één teken, omdat het lege tekenreeksscheidingsteken op elke locatie kan worden gevonden. In het volgende voorbeeld wordt de tekenreeks 'tekens' gesplitst in zoveel elementen als de invoertekenreeks bevat, te beginnen met het teken 'a'. Omdat de null-tekenreeks overeenkomt met het einde van de invoertekenreeks, wordt er een null-tekenreeks ingevoegd aan het einde van de geretourneerde matrix.

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}

De RegexMatchTimeoutException uitzondering wordt gegenereerd als de uitvoeringstijd van de splitsbewerking het time-outinterval overschrijdt dat is opgegeven door de Regex.Regex(String, RegexOptions, TimeSpan) constructor. Als u geen time-outinterval instelt wanneer u de constructor aanroept, wordt de uitzondering gegenereerd als de bewerking een time-outwaarde overschrijdt die is ingesteld voor het toepassingsdomein waarin het Regex-object wordt gemaakt. Als er geen time-out is gedefinieerd in de Regex constructor-aanroep of in de eigenschappen van het toepassingsdomein, of als de time-outwaarde is Regex.InfiniteMatchTimeout, wordt er geen uitzondering gegenereerd

Zie ook

• Reguliere expressietaal - Snelzoekgids

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()

Parameters

Retouren

Een array van tekenreeksen.

Uitzonderingen

Opmerkingen

De Regex.Split methoden zijn vergelijkbaar met de String.Split methode, behalve dat Regex.Split de tekenreeks wordt gesplitst op een scheidingsteken dat wordt bepaald door een reguliere expressie in plaats van een set tekens. De count parameter geeft het maximum aantal subtekenreeksen op waarin de input tekenreeks kan worden gesplitst. De laatste tekenreeks bevat de rest van de splitsing van de tekenreeks. Een count waarde van nul biedt het standaardgedrag om zo vaak mogelijk te splitsen.

Als meerdere overeenkomsten naast elkaar staan of als er een overeenkomst wordt gevonden aan het begin of einde van input, en het aantal gevonden overeenkomsten ten minste twee minder is dan count, wordt een lege tekenreeks ingevoegd in de matrix. Dat wil gezegd, lege tekenreeksen die het resultaat zijn van aangrenzende overeenkomsten of overeenkomsten aan het begin of einde van de invoertekenreeks, worden geteld bij het bepalen of het aantal overeenkomende subtekenreeksen gelijk is countaan . In het volgende voorbeeld wordt de reguliere expressie /d+ gebruikt om een invoertekenreeks te splitsen die een of meer decimale cijfers bevat in maximaal drie subtekenreeksen. Omdat het begin van de invoertekenreeks overeenkomt met het reguliere expressiepatroon, bevat String.Emptyhet eerste matrixelement, de tweede de eerste set alfabetische tekens in de invoertekenreeks en de derde bevat de rest van de tekenreeks die volgt op de derde overeenkomst.

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'

Als haakjes worden vastgelegd in een reguliere expressie, wordt elke vastgelegde tekst opgenomen in de matrix met gesplitste tekenreeksen. Alle matrixelementen die vastgelegde tekst bevatten, worden echter niet meegeteld bij het bepalen of het aantal overeenkomsten is bereikt count. Als u bijvoorbeeld de tekenreeks 'appel-abricot-plum-pear-banana' splitst in maximaal vier subtekenreeksen, resulteert dit in een matrix met zeven elementen, zoals in de volgende code wordt weergegeven.

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'

Als het reguliere expressiepatroon meerdere sets met haakjes vastleggen bevat en er geen overeenkomst wordt gevonden in de eerste set haakjes vastleggen, wordt vastgelegde tekst van extra haakjes vastgelegd in de geretourneerde matrix. Elementen in de geretourneerde matrix die vastgelegde tekst bevatten, worden echter niet meegeteld bij het bepalen of het aantal overeenkomende subtekenreeksen gelijk is countaan . In de volgende code gebruikt een reguliere expressie bijvoorbeeld twee sets haakjes vastleggen om de elementen van een datum uit een datumtekenreeks te extraheren. De eerste set van het vastleggen van haakjes legt het afbreekstreepje vast en de tweede set legt de slash vast. De aanroep van de Split(String, Int32) methode geeft vervolgens maximaal twee elementen in de geretourneerde matrix op. De methode retourneert een tekenreeksmatrix met drie elementen.

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'

Als de reguliere expressie overeenkomt met de lege tekenreeks, Split(String, Int32) wordt de tekenreeks gesplitst in een matrix met tekenreeksen met één teken, omdat het lege tekenreeksscheidingsteken op elke locatie kan worden gevonden. In het volgende voorbeeld wordt de tekenreeks 'tekens' gesplitst in zoveel elementen als in de invoertekenreeks. Omdat de null-tekenreeks overeenkomt met het begin van de invoertekenreeks, wordt een null-tekenreeks ingevoegd aan het begin van de geretourneerde matrix. Dit zorgt ervoor dat het tiende element bestaat uit de twee tekens aan het einde van de invoertekenreeks.

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}

De RegexMatchTimeoutException uitzondering wordt gegenereerd als de uitvoeringstijd van de splitsbewerking het time-outinterval overschrijdt dat is opgegeven door de Regex.Regex(String, RegexOptions, TimeSpan) constructor. Als u geen time-outinterval instelt wanneer u de constructor aanroept, wordt de uitzondering gegenereerd als de bewerking een time-outwaarde overschrijdt die is ingesteld voor het toepassingsdomein waarin het Regex-object wordt gemaakt. Als er geen time-out is gedefinieerd in de Regex constructor-aanroep of in de eigenschappen van het toepassingsdomein, of als de time-outwaarde is Regex.InfiniteMatchTimeout, wordt er geen uitzondering gegenereerd

Zie ook

• Reguliere expressietaal - Snelzoekgids

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()

Parameters

Retouren

Een array van tekenreeksen.

Uitzonderingen

Opmerkingen

De Regex.Split methoden zijn vergelijkbaar met de String.Split(Char[]) methode, behalve dat Regex.Split de tekenreeks wordt gesplitst op een scheidingsteken dat wordt bepaald door een reguliere expressie in plaats van een set tekens. De tekenreeks wordt zo vaak mogelijk gesplitst. Als er geen scheidingsteken wordt gevonden, bevat de retourwaarde één element waarvan de waarde de oorspronkelijke invoertekenreeks is.

Als meerdere overeenkomsten naast elkaar staan, wordt een lege tekenreeks ingevoegd in de matrix. Als u bijvoorbeeld een tekenreeks splitst op één afbreekstreepje, zorgt u ervoor dat de geretourneerde matrix een lege tekenreeks opneemt op de positie waar twee aangrenzende afbreekstreepjes worden gevonden, zoals in de volgende code wordt weergegeven.

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'

Als er een overeenkomst wordt gevonden aan het begin of einde van de invoertekenreeks, wordt een lege tekenreeks opgenomen aan het begin of einde van de geretourneerde matrix. In het volgende voorbeeld wordt het patroon reguliere expressie \d+ gebruikt om een invoertekenreeks op numerieke tekens te splitsen. Omdat de tekenreeks begint en eindigt met overeenkomende numerieke tekens, is String.Emptyde waarde van het eerste en laatste element van de geretourneerde matrix.

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

Als haakjes worden vastgelegd in een Regex.Split expressie, wordt alle vastgelegde tekst opgenomen in de resulterende tekenreeksmatrix. Als u bijvoorbeeld de tekenreeks 'plum-pear' splitst op een afbreekstreepje dat tussen haakjes wordt geplaatst, bevat de geretourneerde matrix een tekenreekselement dat het afbreekstreepje bevat.

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'

Als het reguliere expressiepatroon meerdere sets met haakjes vastleggen bevat en er geen overeenkomst wordt gevonden in de eerste set haakjes vastleggen, wordt vastgelegde tekst van extra haakjes vastgelegd in de geretourneerde matrix.

Als de reguliere expressie overeenkomt met de lege tekenreeks, Split(String) splitst u de tekenreeks in een matrix met tekenreeksen met één teken, omdat het lege tekenreeksscheidingsteken op elke locatie kan worden gevonden. Voorbeeld:

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

De geretourneerde matrix bevat ook een lege tekenreeks aan het begin en einde van de matrix.

De RegexMatchTimeoutException uitzondering wordt gegenereerd als de uitvoeringstijd van de splitsbewerking het time-outinterval overschrijdt dat is opgegeven door de Regex.Regex(String, RegexOptions, TimeSpan) constructor. Als u geen time-outinterval instelt wanneer u de constructor aanroept, wordt de uitzondering gegenereerd als de bewerking een time-outwaarde overschrijdt die is ingesteld voor het toepassingsdomein waarin het Regex-object wordt gemaakt. Als er geen time-out is gedefinieerd in de Regex constructor-aanroep of in de eigenschappen van het toepassingsdomein, of als de time-outwaarde is Regex.InfiniteMatchTimeout, wordt er geen uitzondering gegenereerd

Zie ook

• Reguliere expressietaal - Snelzoekgids

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()

Parameters

Retouren

Een array van tekenreeksen.

Uitzonderingen

Opmerkingen

De Regex.Split methoden zijn vergelijkbaar met de String.Split methode, behalve dat Regex.Split de tekenreeks wordt gesplitst op een scheidingsteken dat wordt bepaald door een reguliere expressie in plaats van een set tekens. De input tekenreeks wordt zo vaak mogelijk gesplitst. Als pattern deze niet wordt gevonden in de input tekenreeks, bevat de retourwaarde één element waarvan de waarde de oorspronkelijke input tekenreeks is.

De pattern parameter bestaat uit reguliere expressietaalelementen die de tekenreeks symbolisch beschrijven die overeenkomen. Zie .NET Reguliere expressies en Regular Expression Language - Quick Reference voor meer informatie over reguliere expressies.

Als meerdere overeenkomsten naast elkaar staan, wordt een lege tekenreeks ingevoegd in de matrix. Als u bijvoorbeeld een tekenreeks splitst op één afbreekstreepje, zorgt u ervoor dat de geretourneerde matrix een lege tekenreeks opneemt op de positie waar twee aangrenzende afbreekstreepjes worden gevonden, zoals in de volgende code wordt weergegeven.

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'

Als er een overeenkomst wordt gevonden aan het begin of einde van de invoertekenreeks, wordt een lege tekenreeks opgenomen aan het begin of einde van de geretourneerde matrix. In het volgende voorbeeld wordt het patroon reguliere expressie \d+ gebruikt om een invoertekenreeks op numerieke tekens te splitsen. Omdat de tekenreeks begint en eindigt met overeenkomende numerieke tekens, is String.Emptyde waarde van het eerste en laatste element van de geretourneerde matrix.

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

Als haakjes worden vastgelegd in een Regex.Split expressie, wordt alle vastgelegde tekst opgenomen in de resulterende tekenreeksmatrix. Als u bijvoorbeeld de tekenreeks 'plum-pear' splitst op een afbreekstreepje dat tussen haakjes wordt geplaatst, bevat de geretourneerde matrix een tekenreekselement dat het afbreekstreepje bevat.

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'

Als het reguliere expressiepatroon meerdere sets met haakjes vastleggen bevat en er geen overeenkomst wordt gevonden in de eerste set haakjes vastleggen, wordt vastgelegde tekst van extra haakjes vastgelegd in de geretourneerde matrix.

Als de reguliere expressie overeenkomt met de lege tekenreeks, Split wordt de tekenreeks gesplitst in een matrix met tekenreeksen met één teken, omdat het lege tekenreeksscheidingsteken op elke locatie kan worden gevonden. Voorbeeld:

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

De geretourneerde matrix bevat ook een lege tekenreeks aan het begin en einde van de matrix.

De RegexMatchTimeoutException uitzondering wordt gegenereerd als de uitvoeringstijd van de splitsbewerking het time-outinterval overschrijdt dat is opgegeven voor het toepassingsdomein waarin de methode wordt aangeroepen. Als er geen time-out is gedefinieerd in de eigenschappen van het toepassingsdomein of als de time-outwaarde is Regex.InfiniteMatchTimeout, wordt er geen uitzondering gegenereerd.

Notities voor bellers

Deze methode treedt op na een interval dat gelijk is aan de standaardtime-outwaarde van het toepassingsdomein waarin de methode wordt aangeroepen. Als er geen time-outwaarde is gedefinieerd voor het toepassingsdomein, wordt de waarde InfiniteMatchTimeout, waardoor er geen time-out optreedt voor de methode, gebruikt. De aanbevolen statische methode voor het splitsen van tekst in een patroonovereenkomst is Split(String, String, RegexOptions, TimeSpan), waarmee u het time-outinterval kunt instellen.

Zie ook

• Taalelementen voor reguliere expressies