Regex.Split 메서드

정의

네임스페이스:

System.Text.RegularExpressions

어셈블리:

System.Text.RegularExpressions.dll

입력 문자열을 정규식 일치로 정의된 위치에 있는 부분 문자열 배열로 분할합니다.

오버로드

Split(String, String, RegexOptions, TimeSpan)	입력 문자열을 지정된 정규식 패턴으로 정의된 위치에 있는 부분 문자열 배열로 분할합니다. 일치 작업을 수정하는 옵션과 일치하는 항목이 없는 경우 시간 제한 간격을 지정하는 추가 매개 변수가 있습니다.
Split(String, String, RegexOptions)	입력 문자열을 지정된 정규식 패턴으로 정의된 위치에 있는 부분 문자열 배열로 분할합니다. 지정한 옵션은 일치 작업을 수정합니다.
Split(String, Int32, Int32)	입력 문자열을 지정된 최대 횟수만큼 하위 문자열 배열로 분할하고 Regex 생성자에 지정된 정규식으로 정의된 위치에 분할합니다. 정규식 패턴에 대한 검색은 입력 문자열의 지정된 문자 위치에서 시작됩니다.
Split(String, String)	입력 문자열을 정규식 패턴으로 정의된 위치에 있는 부분 문자열 배열로 분할합니다.
Split(String)	입력 문자열을 Regex 생성자에 지정된 정규식 패턴으로 정의된 위치에 있는 부분 문자열 배열로 분할합니다.
Split(String, Int32)	입력 문자열을 지정된 최대 횟수만큼 하위 문자열 배열로 분할하고 Regex 생성자에 지정된 정규식으로 정의된 위치에 분할합니다.

Split(String, String, RegexOptions, TimeSpan)

Source:

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

매개 변수

input

String

분할할 문자열입니다.

pattern

String

일치시킬 정규식 패턴입니다.

options

RegexOptions

일치 옵션을 제공하는 열거형 값의 비트 조합입니다.

matchTimeout

TimeSpan

제한 시간 간격 또는 메서드가 시간 초과되지 않아야 함을 나타내는 InfiniteMatchTimeout.

반환

String[]

문자열 배열입니다.

예외

ArgumentException

정규식 구문 분석 오류가 발생했습니다.

ArgumentNullException

input 또는 patternnull.

ArgumentOutOfRangeException

options RegexOptions 값의 유효한 비트 조합이 아닙니다.

-또는-

matchTimeout 음수, 0 또는 약 24일보다 큽니다.

RegexMatchTimeoutException

시간 초과가 발생했습니다. 제한 시간에 대한 자세한 내용은 주의 섹션을 참조하세요.

설명

Regex.Split 메서드는 Regex.Split 문자 집합 대신 정규식에 의해 결정되는 구분 기호에서 문자열을 분할한다는 점을 제외하고 String.Split(Char[]) 메서드와 비슷합니다. 문자열은 가능한 한 여러 번 분할됩니다. 구분 기호를 찾을 수 없는 경우 반환 값은 원래 input 문자열인 요소 하나를 포함합니다.

pattern 매개 변수는 일치시킬 문자열을 상징적으로 설명하는 정규식 언어 요소로 구성됩니다. 정규식에 대한 자세한 내용은 .NET 정규식 및 정규식 언어 - 빠른 참조참조하세요.

중요하다

정적 Split 메서드 호출에 사용되는 컴파일된 정규식은 자동으로 캐시됩니다. 컴파일된 정규식의 수명을 직접 관리하려면 인스턴스 Split 메서드를 사용합니다.

여러 일치 항목이 서로 인접한 경우 빈 문자열이 배열에 삽입됩니다. 예를 들어 단일 하이픈에 문자열을 분할하면 반환된 배열에 인접한 두 하이픈이 있는 위치에 빈 문자열이 포함됩니다.

입력 문자열의 시작 또는 끝에 일치하는 항목이 있으면 반환된 배열의 시작 또는 끝에 빈 문자열이 포함됩니다. 다음 예제에서는 정규식 패턴 [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 식에 사용되는 경우 캡처된 모든 텍스트가 결과 문자열 배열에 포함됩니다. 예를 들어 캡처하는 괄호 안에 배치된 하이픈에서 문자열 "plum-pear"를 분할하는 경우 반환된 배열에는 하이픈이 포함된 문자열 요소가 포함됩니다.

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 예외를 throw합니다. matchTimeout 메서드가 실행되는 애플리케이션 도메인에 대해 정의된 기본 제한 시간 값을 재정의합니다.

호출자 참고

matchTimeout 매개 변수를 2초와 같은 적절한 값으로 설정하는 것이 좋습니다. InfiniteMatchTimeout지정하여 시간 초과를 사용하지 않도록 설정하면 정규식 엔진이 약간 더 나은 성능을 제공합니다. 그러나 다음 조건에서만 시간 초과를 사용하지 않도록 설정해야 합니다.

• 정규식에서 처리된 입력이 알려진 신뢰할 수 있는 원본에서 파생되거나 정적 텍스트로 구성된 경우 사용자가 동적으로 입력한 텍스트는 제외됩니다.

• 정규식 패턴을 철저히 테스트하여 일치 항목, 비 일치 항목 및 근사 일치 항목을 효율적으로 처리하는지 확인합니다.

• 정규식 패턴에 거의 일치 항목을 처리할 때 과도한 역추적을 일으키는 것으로 알려진 언어 요소가 없는 경우

추가 정보

• 정규식 언어 요소

Split(String, String, RegexOptions)

Source:

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

매개 변수

input

String

분할할 문자열입니다.

pattern

String

일치시킬 정규식 패턴입니다.

options

RegexOptions

일치 옵션을 제공하는 열거형 값의 비트 조합입니다.

반환

String[]

문자열 배열입니다.

예외

ArgumentException

정규식 구문 분석 오류가 발생했습니다.

ArgumentNullException

input 또는 patternnull.

ArgumentOutOfRangeException

options RegexOptions 값의 유효한 비트 조합이 아닙니다.

RegexMatchTimeoutException

시간 초과가 발생했습니다. 제한 시간에 대한 자세한 내용은 주의 섹션을 참조하세요.

설명

Regex.Split 메서드는 Regex.Split 문자 집합 대신 정규식에 의해 결정되는 구분 기호에서 문자열을 분할한다는 점을 제외하고 String.Split(Char[]) 메서드와 비슷합니다. 문자열은 가능한 한 여러 번 분할됩니다. 구분 기호를 찾을 수 없는 경우 반환 값은 원래 input 문자열인 요소 하나를 포함합니다.

pattern 매개 변수는 일치시킬 문자열을 상징적으로 설명하는 정규식 언어 요소로 구성됩니다. 정규식에 대한 자세한 내용은 .NET 정규식 및 정규식 언어 - 빠른 참조참조하세요.

중요하다

정적 Split 메서드 호출에 사용되는 컴파일된 정규식은 자동으로 캐시됩니다. 컴파일된 정규식의 수명을 직접 관리하려면 인스턴스 Split 메서드를 사용합니다.

여러 일치 항목이 서로 인접한 경우 빈 문자열이 배열에 삽입됩니다. 예를 들어 단일 하이픈에 문자열을 분할하면 반환된 배열에 인접한 두 하이픈이 있는 위치에 빈 문자열이 포함됩니다.

입력 문자열의 시작 또는 끝에 일치하는 항목이 있으면 반환된 배열의 시작 또는 끝에 빈 문자열이 포함됩니다. 다음 예제에서는 정규식 패턴 [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 식에 사용되는 경우 캡처된 모든 텍스트가 결과 문자열 배열에 포함됩니다. 예를 들어 캡처하는 괄호 안에 배치된 하이픈에서 문자열 "plum-pear"를 분할하는 경우 반환된 배열에는 하이픈이 포함된 문자열 요소가 포함됩니다.

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 예외가 throw됩니다. 애플리케이션 도메인의 속성에 제한 시간이 정의되어 있지 않거나 시간 제한 값이 Regex.InfiniteMatchTimeout경우 예외가 throw되지 않습니다.

호출자 참고

이 메서드는 메서드가 호출되는 애플리케이션 도메인의 기본 제한 시간 값과 동일한 간격 후에 시간 초과됩니다. 애플리케이션 도메인에 대해 제한 시간 값이 정의되지 않은 경우 메서드의 시간 초과를 방지하는 InfiniteMatchTimeout값이 사용됩니다. 패턴 일치에서 텍스트를 분할하는 데 권장되는 정적 메서드는 Split(String, String, RegexOptions, TimeSpan)시간 제한 간격을 설정할 수 있습니다.

추가 정보

• 정규식 언어 요소

Split(String, Int32, Int32)

Source:

Regex.Split.cs

입력 문자열을 지정된 최대 횟수만큼 하위 문자열 배열로 분할하고 Regex 생성자에 지정된 정규식으로 정의된 위치에 분할합니다. 정규식 패턴에 대한 검색은 입력 문자열의 지정된 문자 위치에서 시작됩니다.

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

매개 변수

input

String

분할할 문자열입니다.

count

Int32

분할이 발생할 수 있는 최대 횟수입니다.

startat

Int32

검색이 시작될 입력 문자열의 문자 위치입니다.

반환

String[]

문자열 배열입니다.

예외

ArgumentNullException

input null.

ArgumentOutOfRangeException

startat 0보다 작거나 input길이보다 큽니다.

RegexMatchTimeoutException

시간 초과가 발생했습니다. 제한 시간에 대한 자세한 내용은 주의 섹션을 참조하세요.

설명

Regex.Split 메서드는 Regex.Split 문자 집합 대신 정규식에 의해 결정되는 구분 기호에서 문자열을 분할한다는 점을 제외하고 String.Split 메서드와 비슷합니다. count 매개 변수는 input 문자열이 분할되는 최대 부분 문자열 수를 지정합니다. 마지막 문자열에는 문자열의 언스플리트 나머지가 포함됩니다. count 값 0은 가능한 한 여러 번 분할하는 기본 동작을 제공합니다. startat 매개 변수는 첫 번째 구분 기호 검색이 시작되는 지점을 정의합니다(선행 공백을 건너뛰는 데 사용할 수 있습니다).

startat대한 자세한 내용은 Match(String, Int32)주의 섹션을 참조하세요.

문자열의 count+1 위치에서 일치하는 항목이 없으면 메서드는 input 문자열을 포함하는 하나의 요소 배열을 반환합니다. 하나 이상의 일치 항목이 발견되면 반환된 배열의 첫 번째 요소에는 일치 전에 첫 번째 문자에서 최대 한 문자까지 문자열의 첫 번째 부분이 포함됩니다.

여러 일치 항목이 서로 인접하고 일치하는 항목 수가 count미만인 경우 빈 문자열이 배열에 삽입됩니다. 마찬가지로 문자열의 첫 번째 문자인 startat일치 항목이 발견되면 반환된 배열의 첫 번째 요소는 빈 문자열입니다. 즉, 인접 일치 항목에서 발생하는 빈 문자열은 일치하는 부분 문자열 수가 count같은지 여부를 결정할 때 계산됩니다. 다음 예제에서는 정규식 \d+ 문자열에서 숫자 문자의 첫 번째 부분 문자열의 시작 위치를 찾은 다음 해당 위치에서 시작하여 문자열을 최대 세 번 분할하는 데 사용됩니다. 정규식 패턴이 입력 문자열의 시작 부분과 일치하므로 반환된 문자열 배열은 빈 문자열, 5자 알파벳 문자열 및 나머지 문자열로 구성됩니다.

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-pineapple-peach"를 문자열의 문자 15부터 시작하여 최대 4개의 부분 문자열로 분할하면 다음 코드와 같이 7개 요소 배열이 생성됩니다.

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 문자열을 단일 문자열 배열로 분할합니다. 다음 예제에서는 문자열 "characters"를 입력 문자열에 포함된 만큼의 요소로 분할하고 문자 "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}

분할 작업의 실행 시간이 Regex.Regex(String, RegexOptions, TimeSpan) 생성자가 지정한 제한 시간 간격을 초과하면 RegexMatchTimeoutException 예외가 throw됩니다. 생성자를 호출할 때 제한 시간 간격을 설정하지 않으면 작업이 Regex 개체가 만들어진 애플리케이션 도메인에 대해 설정된 제한 시간 값을 초과하면 예외가 throw됩니다. Regex 생성자 호출 또는 애플리케이션 도메인의 속성에 제한 시간이 정의되지 않거나 제한 시간 값이 Regex.InfiniteMatchTimeout경우 예외가 throw되지 않습니다.

추가 정보

• 정규식 언어 - 빠른 참조

Split(String, String)

Source:

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

매개 변수

input

String

분할할 문자열입니다.

pattern

String

일치시킬 정규식 패턴입니다.

반환

String[]

문자열 배열입니다.

예외

ArgumentException

정규식 구문 분석 오류가 발생했습니다.

ArgumentNullException

input 또는 patternnull.

RegexMatchTimeoutException

시간 초과가 발생했습니다. 제한 시간에 대한 자세한 내용은 주의 섹션을 참조하세요.

설명

Regex.Split 메서드는 Regex.Split 문자 집합 대신 정규식에 의해 결정되는 구분 기호에서 문자열을 분할한다는 점을 제외하고 String.Split 메서드와 비슷합니다. input 문자열은 가능한 한 여러 번 분할됩니다. input 문자열에서 pattern 찾을 수 없는 경우 반환 값은 원래 input 문자열인 요소 하나를 포함합니다.

pattern 매개 변수는 일치시킬 문자열을 상징적으로 설명하는 정규식 언어 요소로 구성됩니다. 정규식에 대한 자세한 내용은 .NET 정규식 및 정규식 언어 - 빠른 참조참조하세요.

중요하다

정적 Split 메서드 호출에 사용되는 컴파일된 정규식은 자동으로 캐시됩니다. 컴파일된 정규식의 수명을 직접 관리하려면 인스턴스 Split 메서드를 사용합니다.

여러 일치 항목이 서로 인접한 경우 빈 문자열이 배열에 삽입됩니다. 예를 들어 단일 하이픈에서 문자열을 분할하면 다음 코드와 같이 두 개의 인접한 하이픈이 있는 위치에 반환된 배열에 빈 문자열이 포함됩니다.

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 식에 사용되는 경우 캡처된 모든 텍스트가 결과 문자열 배열에 포함됩니다. 예를 들어 캡처하는 괄호 안에 배치된 하이픈에서 문자열 "plum-pear"를 분할하는 경우 반환된 배열에는 하이픈이 포함된 문자열 요소가 포함됩니다.

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 예외가 throw됩니다. 애플리케이션 도메인의 속성에 제한 시간이 정의되어 있지 않거나 시간 제한 값이 Regex.InfiniteMatchTimeout경우 예외가 throw되지 않습니다.

호출자 참고

이 메서드는 메서드가 호출되는 애플리케이션 도메인의 기본 제한 시간 값과 동일한 간격 후에 시간 초과됩니다. 애플리케이션 도메인에 대해 제한 시간 값이 정의되지 않은 경우 메서드의 시간 초과를 방지하는 InfiniteMatchTimeout값이 사용됩니다. 패턴 일치에서 텍스트를 분할하는 데 권장되는 정적 메서드는 Split(String, String, RegexOptions, TimeSpan)시간 제한 간격을 설정할 수 있습니다.

추가 정보

• 정규식 언어 요소

Split(String)

Source:

Regex.Split.cs

입력 문자열을 Regex 생성자에 지정된 정규식 패턴으로 정의된 위치에 있는 부분 문자열 배열로 분할합니다.

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

매개 변수

input

String

분할할 문자열입니다.

반환

String[]

문자열 배열입니다.

예외

ArgumentNullException

input null.

RegexMatchTimeoutException

시간 초과가 발생했습니다. 제한 시간에 대한 자세한 내용은 주의 섹션을 참조하세요.

설명

Regex.Split 메서드는 Regex.Split 문자 집합 대신 정규식에 의해 결정되는 구분 기호에서 문자열을 분할한다는 점을 제외하고 String.Split(Char[]) 메서드와 비슷합니다. 문자열은 가능한 한 여러 번 분할됩니다. 구분 기호가 없으면 반환 값에 원래 입력 문자열 값이 있는 요소 하나가 포함됩니다.

여러 일치 항목이 서로 인접한 경우 빈 문자열이 배열에 삽입됩니다. 예를 들어 단일 하이픈에서 문자열을 분할하면 다음 코드와 같이 두 개의 인접한 하이픈이 있는 위치에 반환된 배열에 빈 문자열이 포함됩니다.

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 식에 사용되는 경우 캡처된 모든 텍스트가 결과 문자열 배열에 포함됩니다. 예를 들어 캡처하는 괄호 안에 배치된 하이픈에서 문자열 "plum-pear"를 분할하는 경우 반환된 배열에는 하이픈이 포함된 문자열 요소가 포함됩니다.

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

반환된 배열에는 배열의 시작과 끝에 빈 문자열도 포함됩니다.

분할 작업의 실행 시간이 Regex.Regex(String, RegexOptions, TimeSpan) 생성자가 지정한 제한 시간 간격을 초과하면 RegexMatchTimeoutException 예외가 throw됩니다. 생성자를 호출할 때 제한 시간 간격을 설정하지 않으면 작업이 Regex 개체가 만들어진 애플리케이션 도메인에 대해 설정된 제한 시간 값을 초과하면 예외가 throw됩니다. Regex 생성자 호출 또는 애플리케이션 도메인의 속성에 제한 시간이 정의되지 않거나 제한 시간 값이 Regex.InfiniteMatchTimeout경우 예외가 throw되지 않습니다.

추가 정보

• 정규식 언어 - 빠른 참조

Split(String, Int32)

Source:

Regex.Split.cs

입력 문자열을 지정된 최대 횟수만큼 하위 문자열 배열로 분할하고 Regex 생성자에 지정된 정규식으로 정의된 위치에 분할합니다.

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

매개 변수

input

String

분할할 문자열입니다.

count

Int32

분할이 발생할 수 있는 최대 횟수입니다.

반환

String[]

문자열 배열입니다.

예외

ArgumentNullException

input null.

RegexMatchTimeoutException

시간 초과가 발생했습니다. 제한 시간에 대한 자세한 내용은 주의 섹션을 참조하세요.

설명

Regex.Split 메서드는 Regex.Split 문자 집합 대신 정규식에 의해 결정되는 구분 기호에서 문자열을 분할한다는 점을 제외하고 String.Split 메서드와 비슷합니다. count 매개 변수는 input 문자열을 분할할 수 있는 최대 부분 문자열 수를 지정합니다. 마지막 문자열에는 문자열의 언스플리트 나머지가 포함됩니다. count 값 0은 가능한 한 여러 번 분할하는 기본 동작을 제공합니다.

여러 일치 항목이 서로 인접하거나 일치 항목이 input시작 또는 끝에서 발견되고 일치하는 항목 수가 count미만인 경우 빈 문자열이 배열에 삽입됩니다. 즉, 입력 문자열의 시작 또는 끝에 있는 인접 일치 항목 또는 일치 항목에서 발생하는 빈 문자열은 일치하는 부분 문자열 수가 count같은지 여부를 결정하는 데 계산됩니다. 다음 예제에서는 정규식 /d+ 사용하여 하나 이상의 소수 자릿수를 포함하는 입력 문자열을 최대 3개의 부분 문자열로 분할합니다. 입력 문자열의 시작은 정규식 패턴과 일치하므로 첫 번째 배열 요소에는 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"을 최대 4개의 부분 문자열로 분할하면 7개 요소 배열이 생성됩니다.

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에서 실행되는 경우 메서드는 2개 요소 문자열 배열을 반환합니다. .NET Framework 2.0 이상 버전에서 컴파일되고 실행되는 경우 메서드는 3개 요소 문자열 배열을 반환합니다.

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) 문자열을 단일 문자열 배열로 분할합니다. 다음 예제에서는 문자열 "characters"를 입력 문자열에 있는 만큼의 요소로 분할합니다. null 문자열이 입력 문자열의 시작 부분과 일치하므로 반환된 배열의 시작 부분에 null 문자열이 삽입됩니다. 이렇게 하면 10번째 요소가 입력 문자열의 끝에 있는 두 문자로 구성됩니다.

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}

분할 작업의 실행 시간이 Regex.Regex(String, RegexOptions, TimeSpan) 생성자가 지정한 제한 시간 간격을 초과하면 RegexMatchTimeoutException 예외가 throw됩니다. 생성자를 호출할 때 제한 시간 간격을 설정하지 않으면 작업이 Regex 개체가 만들어진 애플리케이션 도메인에 대해 설정된 제한 시간 값을 초과하면 예외가 throw됩니다. Regex 생성자 호출 또는 애플리케이션 도메인의 속성에 제한 시간이 정의되지 않거나 제한 시간 값이 Regex.InfiniteMatchTimeout경우 예외가 throw되지 않습니다.

추가 정보

• 정규식 언어 - 빠른 참조