Regex.Split Метод

Исходный код:

Regex.Split.cs

Исходный код:

Regex.Split.cs

Исходный код:

Regex.Split.cs

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

Параметры

Возвращаемое значение

Массив строк.

Исключения

Комментарии

Методы Regex.Split похожи на метод String.Split(Char[]), за исключением того, что Regex.Split разбивает строку по разделителю, определяемой регулярным выражением вместо набора символов. Строка разделяется как можно больше раз. Если разделитель не найден, возвращаемое значение содержит один элемент, значение которого является исходной строкой input.

Параметр pattern состоит из элементов языка регулярных выражений, которые символично описывают строку для сопоставления. Дополнительные сведения о регулярных выражениях см. в регулярных выражений .NET и языке регулярных выражений — краткий справочник.

Если несколько совпадений находятся рядом друг с другом, пустая строка вставляется в массив. Например, разделение строки на один дефис приводит к тому, что возвращаемый массив включает пустую строку в положение, где найдены два смежных дефиса.

Если совпадение найдено в начале или конце входной строки, пустая строка включается в начало или конец возвращаемого массива. В следующем примере используется шаблон регулярных выражений [a-z]+ для разделения входной строки на любой букве верхнего или нижнего буквы. Так как строка начинается и заканчивается соответствующими буквами, значение первого и последнего элемента возвращаемого массива String.Empty.

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

Если запись круглых скобок используется в выражении Regex.Split, любой захваченный текст включается в результирующий массив строк. Например, если разделить строку "сливы-груши" на дефис, помещенную в скобки, возвращаемый массив содержит строковый элемент, содержащий дефис.

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'

Однако если шаблон регулярного выражения содержит несколько наборов скобок, поведение этого метода зависит от версии .NET Framework. В .NET Framework 1.0 и 1.1, если совпадение не найдено в первом наборе скобок, захваченный текст из дополнительных скобок записи не включен в возвращаемый массив. Начиная с .NET Framework 2.0 все захваченные тексты также добавляются в возвращаемый массив. Например, следующий код использует два набора записей скобок для извлечения элементов даты, включая разделители дат, из строки даты. Первый набор скобок захватывает дефис, а второй набор фиксирует косую черту. Если пример кода компилируется и выполняется в .NET Framework 1.0 или 1.1, он исключает символы косой черты; Если он компилируется и запускается в .NET Framework 2.0 или более поздних версиях, он включает их.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

Если регулярное выражение может соответствовать пустой строке, Split разделит строку на массив однозначных строк, так как пустой разделитель строк можно найти в каждом расположении.

Параметр matchTimeout указывает, как долго метод сопоставления шаблонов должен попытаться найти совпадение до истечения времени ожидания. Установка интервала времени ожидания запрещает регулярным выражениям, которые полагаются на чрезмерную обратную дорожку, чтобы перестать отвечать на запросы при обработке входных данных, содержащих близкие совпадения. Дополнительные сведения см. в рекомендациях по регулярных выражений и обратного отслеживания. Если совпадение не найдено в этом интервале времени, метод создает исключение RegexMatchTimeoutException. matchTimeout переопределяет любое значение времени ожидания по умолчанию, определенное для домена приложения, в котором выполняется метод.

Примечания для тех, кто вызывает этот метод

Рекомендуется задать для параметра matchTimeout соответствующее значение, например две секунды. Если отключить время ожидания, указав InfiniteMatchTimeout, подсистема регулярных выражений обеспечивает немного лучшую производительность. Однако вы должны отключить тайм-аут только в следующих условиях:

• Если входные данные, обработанные регулярным выражением, являются производными от известного и доверенного источника или состоят из статического текста. Это исключает текст, динамически введенный пользователями.

• При тщательном тестировании шаблона регулярного выражения для эффективной обработки совпадений, не совпадающих и близких совпадений.

• Если шаблон регулярного выражения не содержит языковых элементов, которые, как известно, вызывают чрезмерную обратную дорожку при обработке близкого совпадения.

См. также раздел

• элементы языка регулярных выражений

Исходный код:

Regex.Split.cs

Исходный код:

Regex.Split.cs

Исходный код:

Regex.Split.cs

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

Параметры

Возвращаемое значение

Массив строк.

Исключения

Комментарии

Методы Regex.Split похожи на метод String.Split(Char[]), за исключением того, что Regex.Split разбивает строку по разделителю, определяемой регулярным выражением вместо набора символов. Строка разделяется как можно больше раз. Если разделитель не найден, возвращаемое значение содержит один элемент, значение которого является исходной строкой input.

Параметр pattern состоит из элементов языка регулярных выражений, которые символично описывают строку для сопоставления. Дополнительные сведения о регулярных выражениях см. в регулярных выражений .NET и языке регулярных выражений — краткий справочник.

Если несколько совпадений находятся рядом друг с другом, пустая строка вставляется в массив. Например, разделение строки на один дефис приводит к тому, что возвращаемый массив включает пустую строку в положение, где найдены два смежных дефиса.

Если совпадение найдено в начале или конце входной строки, пустая строка включается в начало или конец возвращаемого массива. В следующем примере используется шаблон регулярных выражений [a-z]+ для разделения входной строки на любой букве верхнего или нижнего буквы. Так как строка начинается и заканчивается соответствующими буквами, значение первого и последнего элемента возвращаемого массива String.Empty.

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

Если запись круглых скобок используется в выражении Regex.Split, любой захваченный текст включается в результирующий массив строк. Например, если разделить строку "сливы-груши" на дефис, помещенную в скобки, возвращаемый массив содержит строковый элемент, содержащий дефис.

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'

Однако если шаблон регулярного выражения содержит несколько наборов скобок, поведение этого метода зависит от версии .NET Framework. В .NET Framework 1.0 и 1.1, если совпадение не найдено в первом наборе скобок, захваченный текст из дополнительных скобок записи не включен в возвращаемый массив. Начиная с .NET Framework 2.0 все захваченные тексты также добавляются в возвращаемый массив. Например, следующий код использует два набора записей скобок для извлечения элементов даты, включая разделители дат, из строки даты. Первый набор скобок захватывает дефис, а второй набор фиксирует косую черту. Если пример кода компилируется и выполняется в .NET Framework 1.0 или 1.1, он исключает символы косой черты; Если он компилируется и запускается в .NET Framework 2.0 или более поздних версиях, он включает их.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

Если регулярное выражение может соответствовать пустой строке, Split разделит строку на массив однозначных строк, так как пустой разделитель строк можно найти в каждом расположении.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции разделения превышает интервал времени ожидания, указанный для домена приложения, в котором вызывается метод. Если время ожидания не определено в свойствах домена приложения или если значение времени ожидания Regex.InfiniteMatchTimeout, исключение не возникает.

Примечания для тех, кто вызывает этот метод

Этот метод истекает после интервала, равного значению времени ожидания по умолчанию домена приложения, в котором вызывается метод. Если значение времени ожидания не определено для домена приложения, используется значение InfiniteMatchTimeout, которое предотвращает истечение времени ожидания метода. Рекомендуемый статический метод разделения текста в совпадении шаблонов Split(String, String, RegexOptions, TimeSpan), что позволяет задать интервал времени ожидания.

См. также раздел

• элементы языка регулярных выражений

Исходный код:

Regex.Split.cs

Исходный код:

Regex.Split.cs

Исходный код:

Regex.Split.cs

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

Параметры

Возвращаемое значение

Массив строк.

Исключения

Комментарии

Методы Regex.Split похожи на метод String.Split, за исключением того, что Regex.Split разбивает строку по разделителю, определяемой регулярным выражением вместо набора символов. Параметр count указывает максимальное количество подстроок, в которых разделена строка input; Последняя строка содержит неспитую оставшуюся часть строки. Значение count нулю обеспечивает поведение по умолчанию разделения как можно больше разбиения. Параметр startat определяет точку, с которой начинается поиск первого разделителя (это можно использовать для пропуска ведущего пробела).

Дополнительные сведения о startatсм. в разделе "Примечания" Match(String, Int32).

Если совпадения не найдены из позиции count+1 в строке, метод возвращает массив одного элемента, содержащий строку input. Если найдено одно или несколько совпадений, первый элемент возвращаемого массива содержит первую часть строки от первого символа до одного символа перед совпадением.

Если несколько совпадений находятся рядом друг с другом, а количество найденных совпадений составляет не менее двух меньше count, пустая строка вставляется в массив. Аналогичным образом, если совпадение найдено в startat, который является первым символом в строке, первый элемент возвращаемого массива является пустой строкой. То есть пустые строки, полученные из смежных совпадений, учитываются при определении числа совпадающих подстроок count. В следующем примере регулярное выражение \d+ используется для поиска начальной позиции первой подстроки числовых символов в строке, а затем для разделения строки не более трех раз, начиная с этой позиции. Поскольку шаблон регулярного выражения соответствует началу входной строки, возвращаемый массив строк состоит из пустой строки, пятизначной алфавитной строки и остальной части строки.

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'

Если запись скобок используется в регулярном выражении, любой захваченный текст включается в массив разделенных строк. Однако все элементы массива, содержащие захваченный текст, не учитываются при определении количества совпадений count. Например, разделение строки ""apple-apricot-plum-pear-pomegranate-ананас-персик" на максимум четыре подстроки, начиная с символа 15 в строке, приводит к семиэлементному массиву элементов, как показано в следующем коде.

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'

Однако если шаблон регулярного выражения содержит несколько наборов скобок, поведение этого метода зависит от версии .NET Framework. В .NET Framework 1.0 и 1.1, если совпадение не найдено в первом наборе записей скобок, захваченный текст из дополнительных скобок записи не включен в возвращаемый массив. Начиная с .NET Framework 2.0 все захваченные тексты также добавляются в возвращаемый массив. Например, следующий код использует два набора записей с скобками для извлечения отдельных слов в строке. Первый набор скобок захватывает дефис, а второй набор фиксирует вертикальную полосу. Если пример кода компилируется и выполняется в .NET Framework 1.0 или 1.1, он исключает символы вертикальной полосы; Если он компилируется и запускается в .NET Framework 2.0 или более поздних версиях, он включает их.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)|([|])";     // possible delimiters found in string
      string input = "apple|apricot|plum|pear|pomegranate|pineapple|peach";

      Regex regex = new Regex(pattern);    
      // Split on delimiters from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// In .NET 2.0 and later, the method returns an array of
// 7 elements, as follows:
//    apple|apricot|plum'
//    '|'
//    'pear'
//    '|'
//    'pomegranate'
//    '|'
//    'pineapple|peach'
// In .NET 1.0 and 1.1, the method returns an array of
// 4 elements, as follows:
//    'apple|apricot|plum'
//    'pear'
//    'pomegranate'
//    'pineapple|peach'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)|([|])"   ' possible delimiters found in string
      Dim input As String = "apple|apricot|plum|pear|pomegranate|pineapple|peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on delimiters from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' In .NET 2.0, the method returns an array of
' 7 elements, as follows:
'    apple|apricot|plum'
'    '|'
'    'pear'
'    '|'
'    'pomegranate'
'    '|'
'    'pineapple|peach'
' In .NET 1.0 and 1.1, the method returns an array of
' 4 elements, as follows:
'    'apple|apricot|plum'
'    'pear'
'    'pomegranate'
'    'pineapple|peach'

Если регулярное выражение может соответствовать пустой строке, Split разделит строку на массив однозначных строк, так как пустой разделитель строк можно найти в каждом расположении. В следующем примере строка "символы" разбивается на столько элементов, сколько содержит входная строка, начиная с символа "a". Так как строка NULL соответствует концу входной строки, в конец возвращаемого массива вставляется строка NULL.

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}

Исключение RegexMatchTimeoutException возникает, если время выполнения операции разделения превышает интервал времени ожидания, указанный конструктором Regex.Regex(String, RegexOptions, TimeSpan). Если при вызове конструктора не задан интервал времени ожидания, исключение создается, если операция превышает любое время ожидания, установленное для домена приложения, в котором создается объект Regex. Если время ожидания не определено в вызове конструктора Regex или в свойствах домена приложения или если значение времени ожидания Regex.InfiniteMatchTimeout, исключение не возникает.

См. также раздел

• язык регулярных выражений — краткий справочник

Исходный код:

Regex.Split.cs

Исходный код:

Regex.Split.cs

Исходный код:

Regex.Split.cs

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

Параметры

Возвращаемое значение

Массив строк.

Исключения

Комментарии

Методы Regex.Split похожи на метод String.Split, за исключением того, что Regex.Split разбивает строку по разделителю, определяемой регулярным выражением вместо набора символов. Строка input разделяется как можно больше раз. Если pattern не найден в строке input, возвращаемое значение содержит один элемент, значение которого является исходной строкой input.

Параметр pattern состоит из элементов языка регулярных выражений, которые символично описывают строку для сопоставления. Дополнительные сведения о регулярных выражениях см. в регулярных выражений .NET и языке регулярных выражений — краткий справочник.

Если несколько совпадений находятся рядом друг с другом, пустая строка вставляется в массив. Например, разделение строки на один дефис приводит к тому, что возвращаемый массив включает пустую строку в положение, где найдены два смежных дефиса, как показано в следующем коде.

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'

Если совпадение найдено в начале или конце входной строки, пустая строка включается в начало или конец возвращаемого массива. В следующем примере используется шаблон регулярного выражения \d+ для разделения входной строки на числовые символы. Так как строка начинается и заканчивается соответствующими числовыми символами, значение первого и последнего элемента возвращаемого массива String.Empty.

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

Если запись круглых скобок используется в выражении Regex.Split, любой захваченный текст включается в результирующий массив строк. Например, если разделить строку "сливы-груши" на дефис, помещенную в скобки, возвращаемый массив содержит строковый элемент, содержащий дефис.

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'

Однако если шаблон регулярного выражения содержит несколько наборов скобок, поведение этого метода зависит от версии .NET Framework. В .NET Framework 1.0 и 1.1, если совпадение не найдено в первом наборе скобок, захваченный текст из дополнительных скобок записи не включен в возвращаемый массив. Начиная с .NET Framework 2.0 все захваченные тексты также добавляются в возвращаемый массив. Например, следующий код использует два набора записей скобок для извлечения элементов даты, включая разделители дат, из строки даты. Первый набор скобок захватывает дефис, а второй набор фиксирует косую черту. Если пример кода компилируется и выполняется в .NET Framework 1.0 или 1.1, он исключает символы косой черты; Если он компилируется и запускается в .NET Framework 2.0 или более поздних версиях, он включает их.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

Если регулярное выражение может соответствовать пустой строке, Split разделит строку на массив однозначных строк, так как пустой разделитель строк можно найти в каждом расположении. Например:

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

Обратите внимание, что возвращаемый массив также содержит пустую строку в начале и конце массива.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции разделения превышает интервал времени ожидания, указанный для домена приложения, в котором вызывается метод. Если время ожидания не определено в свойствах домена приложения или если значение времени ожидания Regex.InfiniteMatchTimeout, исключение не возникает.

Примечания для тех, кто вызывает этот метод

Этот метод истекает после интервала, равного значению времени ожидания по умолчанию домена приложения, в котором вызывается метод. Если значение времени ожидания не определено для домена приложения, используется значение InfiniteMatchTimeout, которое предотвращает истечение времени ожидания метода. Рекомендуемый статический метод разделения текста в совпадении шаблонов Split(String, String, RegexOptions, TimeSpan), что позволяет задать интервал времени ожидания.

См. также раздел

• элементы языка регулярных выражений

Исходный код:

Regex.Split.cs

Исходный код:

Regex.Split.cs

Исходный код:

Regex.Split.cs

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

Параметры

Возвращаемое значение

Массив строк.

Исключения

Комментарии

Методы Regex.Split похожи на метод String.Split(Char[]), за исключением того, что Regex.Split разбивает строку по разделителю, определяемой регулярным выражением вместо набора символов. Строка разделяется как можно больше раз. Если разделитель не найден, возвращаемое значение содержит один элемент, значение которого является исходной входной строкой.

Если несколько совпадений находятся рядом друг с другом, пустая строка вставляется в массив. Например, разделение строки на один дефис приводит к тому, что возвращаемый массив включает пустую строку в положение, где найдены два смежных дефиса, как показано в следующем коде.

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'

Если совпадение найдено в начале или конце входной строки, пустая строка включается в начало или конец возвращаемого массива. В следующем примере используется шаблон регулярного выражения \d+ для разделения входной строки на числовые символы. Так как строка начинается и заканчивается соответствующими числовыми символами, значение первого и последнего элемента возвращаемого массива String.Empty.

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

Если запись круглых скобок используется в выражении Regex.Split, любой захваченный текст включается в результирующий массив строк. Например, если разделить строку "сливы-груши" на дефис, помещенную в скобки, возвращаемый массив содержит строковый элемент, содержащий дефис.

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'

Однако если шаблон регулярного выражения содержит несколько наборов скобок, поведение этого метода зависит от версии .NET Framework. В .NET Framework 1.0 и 1.1, если совпадение не найдено в первом наборе скобок, захваченный текст из дополнительных скобок записи не включен в возвращаемый массив. Начиная с .NET Framework 2.0 все захваченные тексты также добавляются в возвращаемый массив. Например, следующий код использует два набора записей скобок для извлечения элементов даты, включая разделители дат, из строки даты. Первый набор скобок захватывает дефис, а второй набор фиксирует косую черту. Если пример кода компилируется и выполняется в .NET Framework 1.0 или 1.1, он исключает символы косой черты; Если он компилируется и запускается в .NET Framework 2.0 или более поздних версиях, он включает их.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

Если регулярное выражение может соответствовать пустой строке, Split(String) разделит строку на массив однозначных строк, так как пустой разделитель строк можно найти в каждом расположении. Например:

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

Обратите внимание, что возвращаемый массив также содержит пустую строку в начале и конце массива.

Исключение RegexMatchTimeoutException возникает, если время выполнения операции разделения превышает интервал времени ожидания, указанный конструктором Regex.Regex(String, RegexOptions, TimeSpan). Если при вызове конструктора не задан интервал времени ожидания, исключение создается, если операция превышает любое время ожидания, установленное для домена приложения, в котором создается объект Regex. Если время ожидания не определено в вызове конструктора Regex или в свойствах домена приложения или если значение времени ожидания Regex.InfiniteMatchTimeout, исключение не возникает.

См. также раздел

• язык регулярных выражений — краткий справочник

Исходный код:

Regex.Split.cs

Исходный код:

Regex.Split.cs

Исходный код:

Regex.Split.cs

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

Параметры

Возвращаемое значение

Массив строк.

Исключения

Комментарии

Методы Regex.Split похожи на метод String.Split, за исключением того, что Regex.Split разбивает строку по разделителю, определяемой регулярным выражением вместо набора символов. Параметр count указывает максимальное количество подстроок, в которых можно разделить строку input; Последняя строка содержит неспитую оставшуюся часть строки. Значение count нулю обеспечивает поведение по умолчанию разделения как можно больше разбиения.

Если несколько совпадений находятся рядом друг с другом или если совпадение найдено в начале или конце input, а число найденных совпадений составляет не менее двух меньше count, пустая строка вставляется в массив. То есть пустые строки, полученные из смежных совпадений или совпадений в начале или конце входной строки, учитываются при определении числа совпадающих подстроок count. В следующем примере регулярное выражение /d+ используется для разделения входной строки, которая включает одну или несколько десятичных цифр на не более трех подстроок. Так как начало входной строки соответствует шаблону регулярного выражения, первый элемент массива содержит String.Empty, второй содержит первый набор алфавитных символов в входной строке, а третий содержит оставшуюся часть строки, которая следует третьему совпадению.

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'

Если запись скобок используется в регулярном выражении, любой захваченный текст включается в массив разделенных строк. Однако все элементы массива, содержащие захваченный текст, не учитываются при определении количества совпадений count. Например, разделение строки "apple-apricot-plum-pear-banana" на максимум четыре подстроки приводит к массиву семи элементов, как показано в следующем коде.

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'

Однако если шаблон регулярного выражения содержит несколько наборов скобок, поведение этого метода зависит от версии .NET Framework. В .NET Framework 1.0 и 1.1 в возвращенном массиве включен только захваченный текст из первого набора скобок. Начиная с .NET Framework 2.0 все захваченные тексты добавляются в возвращаемый массив. Однако элементы в возвращаемом массиве, содержащее захваченный текст, не учитываются при определении числа сопоставленных подстроек count. Например, в следующем коде регулярное выражение использует два набора скобок для извлечения элементов даты из строки даты. Первый набор скобок захватывает дефис, а второй набор фиксирует косую черту. Вызов метода Split(String, Int32) затем задает не более двух элементов в возвращаемом массиве. Если пример кода компилируется и выполняется в .NET Framework 1.0 или 1.1, метод возвращает массив строк с двумя элементами. Если он компилируется и выполняется в .NET Framework 2.0 или более поздних версиях, метод возвращает массив строк трех элементов.

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'

Если регулярное выражение может соответствовать пустой строке, Split(String, Int32) разделит строку на массив однозначных строк, так как пустой разделитель строк можно найти в каждом расположении. В следующем примере строка "символы" разбивается на столько элементов, сколько в входной строке. Так как строка NULL соответствует началу входной строки, строка NULL вставляется в начале возвращаемого массива. Это приводит к тому, что десятый элемент состоит из двух символов в конце входной строки.

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}

Исключение RegexMatchTimeoutException возникает, если время выполнения операции разделения превышает интервал времени ожидания, указанный конструктором Regex.Regex(String, RegexOptions, TimeSpan). Если при вызове конструктора не задан интервал времени ожидания, исключение создается, если операция превышает любое время ожидания, установленное для домена приложения, в котором создается объект Regex. Если время ожидания не определено в вызове конструктора Regex или в свойствах домена приложения или если значение времени ожидания Regex.InfiniteMatchTimeout, исключение не возникает.

См. также раздел

• язык регулярных выражений — краткий справочник