Regex.Split Metod

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

Parametrar

Returer

En strängmatris.

Undantag

Kommentarer

Metoderna Regex.Split liknar String.Split(Char[]) metoden, förutom att delar strängen vid en avgränsare som Regex.Split bestäms av ett reguljärt uttryck i stället för en uppsättning tecken. Strängen delas så många gånger som möjligt. Om ingen avgränsare hittas innehåller returvärdet ett element vars värde är den ursprungliga input strängen.

Parametern pattern består av reguljära uttrycksspråkelement som symboliskt beskriver strängen som ska matchas. Mer information om reguljära uttryck finns i .NET reguljära uttryck och Regular Expression Language – Snabbreferens.

Om flera matchningar är intill varandra infogas en tom sträng i matrisen. Om du till exempel delar upp en sträng på ett enda bindestreck får den returnerade matrisen att innehålla en tom sträng i den position där två intilliggande bindestreck hittas.

Om en matchning hittas i början eller slutet av indatasträngen inkluderas en tom sträng i början eller slutet av den returnerade matrisen. I följande exempel används mönster [a-z]+ för reguljära uttryck för att dela en indatasträng på versaler eller gemener i alfabetisk ordning. Eftersom strängen börjar och slutar med matchande alfabetiska tecken är String.Emptyvärdet för det första och sista elementet i den returnerade matrisen .

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

Om samlande parenteser används i ett Regex.Split uttryck inkluderas all insamlad text i den resulterande strängmatrisen. Om du till exempel delar strängen "plum-pear" på ett bindestreck som placeras inom samlande parenteser innehåller den returnerade matrisen ett strängelement som innehåller bindestrecket.

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'

Men när det reguljära uttrycksmönstret innehåller flera uppsättningar av samlande parenteser och en matchning inte hittas inom den första uppsättningen av samlande parenteser inkluderas inspelad text från ytterligare samlande parenteser i den returnerade matrisen.

Om det reguljära uttrycket kan matcha den tomma strängen Split , delas strängen upp i en matris med strängar med en tecken eftersom den tomma strängen avgränsare kan hittas på varje plats.

Parametern matchTimeout anger hur länge en mönstermatchningsmetod ska försöka hitta en matchning innan tidsgränsen uppnås. Om du anger ett tidsgränsintervall förhindras reguljära uttryck som förlitar sig på överdriven bakåtspårning från att verka sluta svara när de bearbetar indata som innehåller nära matchningar. Mer information finns i Metodtips för reguljära uttryck och bakåtspårning. Om ingen matchning hittas i det tidsintervallet utlöser metoden ett RegexMatchTimeoutException undantag. matchTimeout åsidosätter alla standardvärden för timeout som definierats för programdomänen där metoden körs.

Anteckningar till anropare

Vi rekommenderar att du anger parametern matchTimeout till ett lämpligt värde, till exempel två sekunder. Om du inaktiverar tidsgränser genom att ange ger motorn för reguljära InfiniteMatchTimeoututtryck något bättre prestanda. Du bör dock inaktivera tidsgränser endast under följande villkor:

• När indata som bearbetas av ett reguljärt uttryck härleds från en känd och betrodd källa eller består av statisk text. Detta exkluderar text som har matats in dynamiskt av användare.

• När mönstret för reguljära uttryck har testats noggrant för att säkerställa att det effektivt hanterar matchningar, icke-matchningar och nära matchningar.

• När det reguljära uttrycksmönstret inte innehåller några språkelement som är kända för att orsaka överdriven bakåtspårning vid bearbetning av en nära matchning.

Se även

• Språkelement för reguljära uttryck

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

Parametrar

Returer

En matris med strängar.

Undantag

Kommentarer

Metoderna Regex.Split liknar String.Split(Char[]) metoden, förutom att delar strängen vid en avgränsare som Regex.Split bestäms av ett reguljärt uttryck i stället för en uppsättning tecken. Strängen delas så många gånger som möjligt. Om ingen avgränsare hittas innehåller returvärdet ett element vars värde är den ursprungliga input strängen.

Parametern pattern består av reguljära uttrycksspråkelement som symboliskt beskriver strängen som ska matchas. Mer information om reguljära uttryck finns i .NET reguljära uttryck och Regular Expression Language – Snabbreferens.

Om flera matchningar är intill varandra infogas en tom sträng i matrisen. Om du till exempel delar upp en sträng på ett enda bindestreck får den returnerade matrisen att innehålla en tom sträng i den position där två intilliggande bindestreck hittas.

Om en matchning hittas i början eller slutet av indatasträngen inkluderas en tom sträng i början eller slutet av den returnerade matrisen. I följande exempel används mönster [a-z]+ för reguljära uttryck för att dela en indatasträng på versaler eller gemener i alfabetisk ordning. Eftersom strängen börjar och slutar med matchande alfabetiska tecken är String.Emptyvärdet för det första och sista elementet i den returnerade matrisen .

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

Om samlande parenteser används i ett Regex.Split uttryck inkluderas all insamlad text i den resulterande strängmatrisen. Om du till exempel delar strängen "plum-pear" på ett bindestreck som placeras inom samlande parenteser innehåller den returnerade matrisen ett strängelement som innehåller bindestrecket.

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'

Men när det reguljära uttrycksmönstret innehåller flera uppsättningar av samlande parenteser och en matchning inte hittas inom den första uppsättningen av samlande parenteser inkluderas inspelad text från ytterligare samlande parenteser i den returnerade matrisen.

Om det reguljära uttrycket kan matcha den tomma strängen Split , delas strängen upp i en matris med strängar med en tecken eftersom den tomma strängen avgränsare kan hittas på varje plats.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för delningsåtgärden överskrider det tidsgränsintervall som angetts för programdomänen där metoden anropas. Om ingen tidsgräns har definierats i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag.

Anteckningar till anropare

Den här metoden överskrider tidsgränsen efter ett intervall som är lika med standardvärdet för tidsgränsen för programdomänen där metoden anropas. Om ett timeout-värde inte har definierats för programdomänen används värdet InfiniteMatchTimeout, som förhindrar att metoden överskrider tidsgränsen. Den rekommenderade statiska metoden för att dela upp text på en mönstermatchning är Split(String, String, RegexOptions, TimeSpan), vilket gör att du kan ange tidsgränsintervallet.

Se även

• Språkelement för reguljära uttryck

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

Parametrar

Returer

En matris med strängar.

Undantag

Kommentarer

Metoderna Regex.Split liknar String.Split metoden, förutom att delar strängen vid en avgränsare som Regex.Split bestäms av ett reguljärt uttryck i stället för en uppsättning tecken. Parametern count anger det maximala antalet delsträngar som strängen input delas i. Den sista strängen innehåller resten av strängen som inte är markerad. Värdet count noll ger standardbeteendet att dela upp så många gånger som möjligt. Parametern startat definierar den punkt där sökningen efter den första avgränsare börjar (detta kan användas för att hoppa över inledande tomt utrymme).

Mer information om startatfinns i avsnittet Kommentarer i Match(String, Int32).

Om inga matchningar hittas från count+1-positionen i strängen returnerar metoden en enelementsmatris som innehåller strängen input . Om en eller flera matchningar hittas innehåller det första elementet i den returnerade matrisen den första delen av strängen från det första tecknet upp till ett tecken före matchningen.

Om flera matchningar är intill varandra och antalet matchningar som hittas är minst två mindre än count, infogas en tom sträng i matrisen. Om en matchning hittas på startat, vilket är det första tecknet i strängen, är det första elementet i den returnerade matrisen en tom sträng. Det innebär att tomma strängar som härrör från intilliggande matchningar räknas för att avgöra om antalet matchade understrängar countär lika med . I följande exempel används det reguljära uttrycket \d+ för att hitta startpositionen för den första delsträngen av numeriska tecken i en sträng och sedan dela upp strängen högst tre gånger från och med den positionen. Eftersom mönstret för reguljära uttryck matchar början av indatasträngen består den returnerade strängmatrisen av en tom sträng, en alfabetisk sträng med fem tecken och resten av strängen.

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'

Om samlande parenteser används i ett reguljärt uttryck inkluderas all insamlad text i matrisen med delade strängar. Alla matriselement som innehåller insamlad text räknas dock inte för att avgöra om antalet matchningar har nått count. Om du till exempel delar upp strängen "apple-apricot-plum-pear-pomegranate-ananas-peach" i högst fyra delsträngar som börjar på tecken 15 i strängen resulterar det i en matris med sju element, som följande kod visar.

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'

Men när det reguljära uttrycksmönstret innehåller flera uppsättningar av samlande parenteser och en matchning inte hittas inom den första uppsättningen av samlande parenteser, inkluderas inspelad text från ytterligare samlande parenteser i den returnerade matrisen.

Om det reguljära uttrycket kan matcha den tomma strängen Split delar du upp strängen i en matris med strängar med en tecken eftersom den tomma sträng avgränsaren finns på varje plats. I följande exempel delas strängen "tecken" upp i så många element som indatasträngen innehåller, med början med tecknet "a". Eftersom null-strängen matchar slutet av indatasträngen infogas en nullsträng i slutet av den returnerade matrisen.

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}

Undantaget RegexMatchTimeoutException utlöses om körningstiden för delningsåtgärden överskrider det tidsgränsintervall som anges av Regex.Regex(String, RegexOptions, TimeSpan) konstruktorn. Om du inte anger ett tidsgränsintervall när du anropar konstruktorn utlöses undantaget om åtgärden överskrider ett timeout-värde som har upprättats för programdomänen Regex där objektet skapas. Om ingen tidsgräns har definierats i konstruktoranropet Regex eller i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag

Se även

• Språk för reguljärt uttryck – snabbreferens

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

Parametrar

Returer

En matris med strängar.

Undantag

Kommentarer

Metoderna Regex.Split liknar String.Split metoden, förutom att delar strängen vid en avgränsare som Regex.Split bestäms av ett reguljärt uttryck i stället för en uppsättning tecken. Parametern count anger det maximala antalet delsträngar som strängen input kan delas upp i. Den sista strängen innehåller resten av strängen som inte är markerad. Värdet count noll ger standardbeteendet att dela upp så många gånger som möjligt.

Om flera matchningar är intill varandra eller om en matchning hittas i början eller slutet av input, och antalet matchningar som hittas är minst två mindre än count, infogas en tom sträng i matrisen. Det innebär att tomma strängar som härrör från intilliggande matchningar eller matchningar i början eller slutet av indatasträngen räknas för att avgöra om antalet matchade delsträngar är lika med count. I följande exempel används det reguljära uttrycket /d+ för att dela upp en indatasträng som innehåller en eller flera decimalsiffror i högst tre delsträngar. Eftersom indatasträngens början matchar mönster för reguljära uttryck innehåller String.Emptydet första matriselementet , det andra innehåller den första uppsättningen alfabetiska tecken i indatasträngen och den tredje innehåller resten av strängen som följer den tredje matchningen.

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'

Om samlande parenteser används i ett reguljärt uttryck inkluderas all insamlad text i matrisen med delade strängar. Alla matriselement som innehåller insamlad text räknas dock inte för att avgöra om antalet matchningar har nått count. Att dela upp strängen "apple-apricot-plum-pear-banana" i högst fyra delsträngar resulterar till exempel i en matris med sju element, som följande kod visar.

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'

Om det reguljära uttrycksmönstret innehåller flera uppsättningar av samlande parenteser och en matchning inte hittas inom den första uppsättningen av samlande parenteser inkluderas inspelad text från ytterligare samlande parenteser i den returnerade matrisen. Element i den returnerade matrisen som innehåller insamlad text räknas dock inte för att avgöra om antalet matchade delsträngar är lika med count. I följande kod använder till exempel ett reguljärt uttryck två uppsättningar av samlande parenteser för att extrahera elementen i ett datum från en datumsträng. Den första uppsättningen av samlande parenteser fångar bindestrecket och den andra uppsättningen fångar in snedstrecket framåt. Anropet Split(String, Int32) till metoden anger sedan högst två element i den returnerade matrisen. Metoden returnerar en strängmatris med tre element.

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'

Om det reguljära uttrycket kan matcha den tomma strängen Split(String, Int32) , delas strängen upp i en matris med strängar med en tecken eftersom den tomma strängen avgränsare kan hittas på varje plats. I följande exempel delas strängen "tecken" upp i så många element som det finns i indatasträngen. Eftersom null-strängen matchar början av indatasträngen infogas en nullsträng i början av den returnerade matrisen. Detta gör att det tionde elementet består av de två tecknen i slutet av indatasträngen.

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}

Undantaget RegexMatchTimeoutException utlöses om körningstiden för delningsåtgärden överskrider det tidsgränsintervall som anges av Regex.Regex(String, RegexOptions, TimeSpan) konstruktorn. Om du inte anger ett tidsgränsintervall när du anropar konstruktorn utlöses undantaget om åtgärden överskrider ett timeout-värde som har upprättats för programdomänen Regex där objektet skapas. Om ingen tidsgräns har definierats i konstruktoranropet Regex eller i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag

Se även

• Språk för reguljärt uttryck – snabbreferens

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

Parametrar

Returer

En matris med strängar.

Undantag

Kommentarer

Metoderna Regex.Split liknar String.Split(Char[]) metoden, förutom att delar strängen vid en avgränsare som Regex.Split bestäms av ett reguljärt uttryck i stället för en uppsättning tecken. Strängen delas så många gånger som möjligt. Om ingen avgränsare hittas innehåller returvärdet ett element vars värde är den ursprungliga indatasträngen.

Om flera matchningar är intill varandra infogas en tom sträng i matrisen. Om du till exempel delar upp en sträng på ett enda bindestreck får den returnerade matrisen att innehålla en tom sträng i den position där två intilliggande bindestreck hittas, som följande kod visar.

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'

Om en matchning hittas i början eller slutet av indatasträngen inkluderas en tom sträng i början eller slutet av den returnerade matrisen. I följande exempel används mönster \d+ för reguljära uttryck för att dela en indatasträng på numeriska tecken. Eftersom strängen börjar och slutar med matchande numeriska tecken är String.Emptyvärdet för det första och sista elementet i den returnerade matrisen .

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

Om samlande parenteser används i ett Regex.Split uttryck inkluderas all insamlad text i den resulterande strängmatrisen. Om du till exempel delar strängen "plum-pear" på ett bindestreck som placeras inom samlande parenteser innehåller den returnerade matrisen ett strängelement som innehåller bindestrecket.

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'

Om det reguljära uttrycksmönstret innehåller flera uppsättningar av samlande parenteser och en matchning inte hittas inom den första uppsättningen av samlande parenteser inkluderas inspelad text från ytterligare samlande parenteser i den returnerade matrisen.

Om det reguljära uttrycket kan matcha den tomma strängen Split(String) delar du upp strängen i en matris med strängar med en tecken eftersom den tomma sträng avgränsaren finns på varje plats. Ett exempel:

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

Observera att den returnerade matrisen även innehåller en tom sträng i början och slutet av matrisen.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för delningsåtgärden överskrider det tidsgränsintervall som anges av Regex.Regex(String, RegexOptions, TimeSpan) konstruktorn. Om du inte anger ett tidsgränsintervall när du anropar konstruktorn utlöses undantaget om åtgärden överskrider ett timeout-värde som har upprättats för programdomänen Regex där objektet skapas. Om ingen tidsgräns har definierats i konstruktoranropet Regex eller i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag

Se även

• Språk för reguljärt uttryck – snabbreferens

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

Parametrar

Returer

En matris med strängar.

Undantag

Kommentarer

Metoderna Regex.Split liknar String.Split metoden, förutom att delar strängen vid en avgränsare som Regex.Split bestäms av ett reguljärt uttryck i stället för en uppsättning tecken. Strängen input delas så många gånger som möjligt. Om pattern inte hittas i strängen input innehåller returvärdet ett element vars värde är den ursprungliga input strängen.

Parametern pattern består av reguljära uttrycksspråkelement som symboliskt beskriver strängen som ska matchas. Mer information om reguljära uttryck finns i .NET reguljära uttryck och Regular Expression Language – Snabbreferens.

Om flera matchningar är intill varandra infogas en tom sträng i matrisen. Om du till exempel delar upp en sträng på ett enda bindestreck får den returnerade matrisen att innehålla en tom sträng i den position där två intilliggande bindestreck hittas, som följande kod visar.

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'

Om en matchning hittas i början eller slutet av indatasträngen inkluderas en tom sträng i början eller slutet av den returnerade matrisen. I följande exempel används mönster \d+ för reguljära uttryck för att dela en indatasträng på numeriska tecken. Eftersom strängen börjar och slutar med matchande numeriska tecken är String.Emptyvärdet för det första och sista elementet i den returnerade matrisen .

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

Om samlande parenteser används i ett Regex.Split uttryck inkluderas all insamlad text i den resulterande strängmatrisen. Om du till exempel delar strängen "plum-pear" på ett bindestreck som placeras inom samlande parenteser innehåller den returnerade matrisen ett strängelement som innehåller bindestrecket.

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'

Om det reguljära uttrycksmönstret innehåller flera uppsättningar av samlande parenteser och en matchning inte hittas inom den första uppsättningen av samlande parenteser inkluderas inspelad text från ytterligare samlande parenteser i den returnerade matrisen.

Om det reguljära uttrycket kan matcha den tomma strängen Split , delas strängen upp i en matris med strängar med en tecken eftersom den tomma strängen avgränsare kan hittas på varje plats. Ett exempel:

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

Observera att den returnerade matrisen även innehåller en tom sträng i början och slutet av matrisen.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för delningsåtgärden överskrider det tidsgränsintervall som angetts för programdomänen där metoden anropas. Om ingen tidsgräns har definierats i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag.

Anteckningar till anropare

Den här metoden överskrider tidsgränsen efter ett intervall som är lika med standardvärdet för tidsgränsen för programdomänen där metoden anropas. Om ett timeout-värde inte har definierats för programdomänen används värdet InfiniteMatchTimeout, som förhindrar att metoden överskrider tidsgränsen. Den rekommenderade statiska metoden för att dela upp text på en mönstermatchning är Split(String, String, RegexOptions, TimeSpan), vilket gör att du kan ange tidsgränsintervallet.

Se även

• Språkelement för reguljära uttryck