String.Split 메서드

정의

지정된 문자열 또는 유니코드 문자 배열의 요소로 구분된 이 인스턴스의 부분 문자열이 포함된 문자열 배열을 반환합니다.Returns a string array that contains the substrings in this instance that are delimited by elements of a specified string or Unicode character array.

오버로드

Split(Char[], Int32, StringSplitOptions)

배열에 있는 문자에 따라 최대 개수의 부분 문자열로 문자열을 분할합니다.Splits a string into a maximum number of substrings based on the characters in an array.

Split(Char, Int32, StringSplitOptions)

제공된 문자 구분 기호에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다.Splits a string into a maximum number substrings based on the provided character separator.

Split(String[], Int32, StringSplitOptions)

배열에 있는 문자열에 따라 최대 개수의 부분 문자열로 문자열을 분할합니다.Splits a string into a maximum number of substrings based on the strings in an array. 부분 문자열이 빈 배열 요소를 포함하는지 여부를 지정할 수 있습니다.You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions)

배열에 있는 문자열에 따라 문자열을 부분 문자열로 분할합니다.Splits a string into substrings based on the strings in an array. 부분 문자열이 빈 배열 요소를 포함하는지 여부를 지정할 수 있습니다.You can specify whether the substrings include empty array elements.

Split(String, Int32, StringSplitOptions)

제공된 문자열 구분 기호에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다.Splits a string into a maximum number of substrings based on the provided string separator.

Split(Char[], StringSplitOptions)

배열에 있는 문자에 따라 문자열을 부분 문자열로 분할합니다.Splits a string into substrings based on the characters in an array. 부분 문자열이 빈 배열 요소를 포함하는지 여부를 지정할 수 있습니다.You can specify whether the substrings include empty array elements.

Split(Char[], Int32)

배열에 있는 문자에 따라 최대 개수의 부분 문자열로 문자열을 분할합니다.Splits a string into a maximum number of substrings based on the characters in an array. 반환할 부분 문자열의 최대 수도 지정합니다.You also specify the maximum number of substrings to return.

Split(Char, StringSplitOptions)

제공된 문자 구분 기호에 따라 문자열을 부분 문자열로 분할합니다.Splits a string into substrings based on the provided character separator.

Split(String, StringSplitOptions)

문자열을 제공된 문자열 구분 기호에 기초하는 부분 문자열로 분할합니다.Splits a string into substrings that are based on the provided string separator.

Split(Char[])

문자열을 구분 기호 배열 내 문자에 기초하는 부분 문자열로 분할합니다.Splits a string into substrings that are based on the characters in the separator array.

설명

Split는 구분 된 문자열을 부분 문자열로 구분 하는 데 사용 됩니다.Split is used to break a delimited string into substrings. 문자 배열 중 하나를 사용 하 여 0 개, 1 개 또는 여러 개의 구분 문자 (Split(Char[]) 메서드)를 지정 하거나, 문자 배열을 사용 하 여 0 개, 1 개 또는 여러 개의 구분 문자열을 지정할 수 있습니다.You can use either a character array to specify zero, one, or multiple delimiting characters (the Split(Char[]) method), or you can use a character array to specify zero, one, or multiple delimiting strings. Split 메서드의 오버 로드를 사용 하면 메서드가 반환 하는 부분 문자열의 수를 제한할 수 있습니다 (Split(Char[], Int32) 메서드). 빈 문자열이 반환 된 부분 문자열 (Split(Char[], StringSplitOptions)Split(String[], StringSplitOptions) 메서드)에 포함 되는지 여부를 확인 하거나 둘 다 (Split(Char[], Int32, StringSplitOptions)Split(String[], Int32, StringSplitOptions) 메서드)를 수행할 수 있습니다.Overloads of the Split method allow you to limit the number of substrings returned by the method (the Split(Char[], Int32) method), to determine whether empty strings are included in the returned substrings (the Split(Char[], StringSplitOptions) and Split(String[], StringSplitOptions) methods, or to do both (the Split(Char[], Int32, StringSplitOptions) and Split(String[], Int32, StringSplitOptions) methods).

String.Split에 대 한 대안Alternatives to String.Split

Split 메서드는 구분 된 문자열을 부분 문자열로 분리 하는 것이 항상 가장 좋은 방법은 아닙니다.The Split method is not always the best way to break a delimited string into substrings. 모든 구분된 된 문자열의 부분 문자열을 추출 하지 않으려는 경우 또는 구분 기호 문자 집합이 아니라 패턴에 따라 문자열을 구문 분석 하려는 경우 다음 대안을 고려 합니다.If you don't want to extract all of the substrings of a delimited string, or if you want to parse a string based on a pattern instead of a set of delimiter characters, consider the following alternatives.

정규식Regular expressions

문자열 고정된 패턴을 준수 하는 경우 압축을 풀고 해당 요소를 처리 하는 정규식을 사용할 수 있습니다.If your strings conform to a fixed pattern, you can use a regular expression to extract and handle their elements. 예를 들어 문자열이 "number 피연산자 number" 형식을 사용 하는 경우 정규식 을 사용 하 여 문자열의 요소를 추출 하 고 처리할 수 있습니다.For example, if strings take the form "number operand number" you can use a regular expression to extract and handle the string's elements. 예를 들면 다음과 같습니다.Here's an example:

   String[] expressions = { "16 + 21", "31 * 3", "28 / 3",
                            "42 - 18", "12 * 7",
                            "2, 4, 6, 8" };
   String pattern = @"(\d+)\s+([-+*/])\s+(\d+)";
   foreach (var expression in expressions)
      foreach (System.Text.RegularExpressions.Match m in 
      System.Text.RegularExpressions.Regex.Matches(expression, pattern)) {
         int value1 = Int32.Parse(m.Groups[1].Value);
         int value2 = Int32.Parse(m.Groups[3].Value);
         switch (m.Groups[2].Value)
         {
            case "+":
               Console.WriteLine("{0} = {1}", m.Value, value1 + value2);
               break;
            case "-":
               Console.WriteLine("{0} = {1}", m.Value, value1 - value2);
               break;
            case "*":
               Console.WriteLine("{0} = {1}", m.Value, value1 * value2);
               break;
            case "/":
               Console.WriteLine("{0} = {1:N2}", m.Value, value1 / value2);
               break;
         }
      }
// The example displays the following output:
//       16 + 21 = 37
//       31 * 3 = 93
//       28 / 3 = 9.33
//       42 - 18 = 24
//       12 * 7 = 84
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim expressions() As String = { "16 + 21", "31 * 3", "28 / 3",
                                      "42 - 18", "12 * 7",
                                      "2, 4, 6, 8" }

      Dim pattern As String = "(\d+)\s+([-+*/])\s+(\d+)"
      For Each expression In expressions
         For Each m As Match in Regex.Matches(expression, pattern)
            Dim value1 As Integer = Int32.Parse(m.Groups(1).Value)
            Dim value2 As Integer = Int32.Parse(m.Groups(3).Value)
            Select Case m.Groups(2).Value
               Case "+"
                  Console.WriteLine("{0} = {1}", m.Value, value1 + value2)
               Case "-"
                  Console.WriteLine("{0} = {1}", m.Value, value1 - value2)
               Case "*"
                  Console.WriteLine("{0} = {1}", m.Value, value1 * value2)
               Case "/"
                  Console.WriteLine("{0} = {1:N2}", m.Value, value1 / value2)
            End Select
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       16 + 21 = 37
'       31 * 3 = 93
'       28 / 3 = 9.33
'       42 - 18 = 24
'       12 * 7 = 84

정규식 패턴 (\d+)\s+([-+*/])\s+(\d+)은 다음과 같이 정의 됩니다.The regular expression pattern (\d+)\s+([-+*/])\s+(\d+) is defined like this:

패턴Pattern 설명Description
(\d+) 하나 이상의 10진수 숫자가 일치하는지 확인합니다.Match one or more decimal digits. 이 그룹은 첫 번째 캡처링 그룹입니다.This is the first capturing group.
\s+ 하나 이상의 공백 문자를 찾습니다.Match one or more white-space characters.
([-+*/]) 일치는 산술 연산자 기호 (+,-, *, 또는 /).Match an arithmetic operator sign (+, -, *, or /). 이 그룹은 두 번째 캡처링 그룹입니다.This is the second capturing group.
\s+ 하나 이상의 공백 문자를 찾습니다.Match one or more white-space characters.
(\d+) 하나 이상의 10진수 숫자가 일치하는지 확인합니다.Match one or more decimal digits. 이 그룹은 세 번째 캡처링 그룹입니다.This is the third capturing group.

또한 고정된 문자 집합이 아닌 패턴을 기반으로 문자열에서 부분 문자열을 추출 하는 정규식을 사용할 수 있습니다.You can also use a regular expression to extract substrings from a string based on a pattern rather than a fixed set of characters. 이러한 조건 중 하나가 발생 하면 일반적인 시나리오입니다.This is a common scenario when either of these conditions occurs:

  • 하나 이상의 구분 기호 문자는 항상 String 인스턴스에서 구분 기호로 사용 되지 않습니다.One or more of the delimiter characters does not always serve as a delimiter in the String instance.

  • 순서 및 구분 기호 문자의 수를 변수 이거나 알 수는 있습니다.The sequence and number of delimiter characters is variable or unknown.

예를 들어 Split 메서드는 다음 문자열을 분할 하는 데 사용할 수 없습니다. \n (의 C#경우) 또는 vbCrLf (Visual Basic) 문자 수가 변수 이므로 항상 구분 기호로 사용 되지 않기 때문입니다.For example, the Split method cannot be used to split the following string, because the number of \n (in C#) or vbCrLf (in Visual Basic) characters is variable, and they don't always serve as delimiters.

[This is captured\ntext.]\n\n[\n[This is more captured text.]\n]
\n[Some more captured text:\n   Option1\n   Option2][Terse text.]

정규식을 쉽게 다음 예와 같이이 문자열을 분할할 수 있습니다.A regular expression can split this string easily, as the following example shows.

String input = "[This is captured\ntext.]\n\n[\n" +
               "[This is more captured text.]\n]\n" +
               "[Some more captured text:\n   Option1" +
               "\n   Option2][Terse text.]";
String pattern = @"\[([^\[\]]+)\]";
int ctr = 0;
foreach (System.Text.RegularExpressions.Match m in 
   System.Text.RegularExpressions.Regex.Matches(input, pattern))
   Console.WriteLine("{0}: {1}", ++ctr, m.Groups[1].Value);
// The example displays the following output:
//       1: This is captured
//       text.
//       2: This is more captured text.
//       3: Some more captured text:
//          Option1
//          Option2
//       4: Terse text.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = String.Format("[This is captured{0}text.]" +
                                          "{0}{0}[{0}[This is more " +
                                          "captured text.]{0}{0}" +
                                          "[Some more captured text:" +
                                          "{0}   Option1" +
                                          "{0}   Option2][Terse text.]",
                                          vbCrLf)
      Dim pattern As String = "\[([^\[\]]+)\]"
      Dim ctr As Integer = 0
      For Each m As Match In Regex.Matches(input, pattern)
         ctr += 1
         Console.WriteLine("{0}: {1}", ctr, m.Groups(1).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       1: This is captured
'       text.
'       2: This is more captured text.
'       3: Some more captured text:
'          Option1
'          Option2
'       4: Terse text.

정규식 패턴 \[([^\[\]]+)\]은 다음과 같이 정의 됩니다.The regular expression pattern \[([^\[\]]+)\] is defined like this:

패턴Pattern 설명Description
\[ 여는 대괄호와 일치 합니다.Match an opening bracket.
([^\[\]]+) 없는 열거나 닫는 대괄호를 한 번 이상 문자를 찾습니다.Match any character that is not an opening or a closing bracket one or more times. 이 그룹은 첫 번째 캡처링 그룹입니다.This is the first capturing group.
\] 닫는 괄호를 일치 합니다.Match a closing bracket.

Regex.Split 메서드는 고정 문자 집합 대신 정규식 패턴을 기반으로 문자열을 분할 한다는 점을 제외 하 고는 String.Split와 거의 동일 합니다.The Regex.Split method is almost identical to String.Split, except that it splits a string based on a regular expression pattern instead of a fixed character set. 예를 들어 다음 예제에서는 Regex.Split 메서드를 사용 하 여 다양 한 하이픈 및 기타 문자의 조합으로 구분 된 부분 문자열이 포함 된 문자열을 분할 합니다.For example, the following example uses the Regex.Split method to split a string that contains substrings delimited by various combinations of hyphens and other characters.

String input = "abacus -- alabaster - * - atrium -+- " +
               "any -*- actual - + - armoire - - alarm";
String pattern = @"\s-\s?[+*]?\s?-\s";
String[] elements = System.Text.RegularExpressions.Regex.Split(input, pattern);
foreach (var element in elements)
   Console.WriteLine(element);

// The example displays the following output:
//       abacus
//       alabaster
//       atrium
//       any
//       actual
//       armoire
//       alarm
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "abacus -- alabaster - * - atrium -+- " +
                            "any -*- actual - + - armoir - - alarm"
      Dim pattern As String = "\s-\s?[+*]?\s?-\s"
      Dim elements() As String = Regex.Split(input, pattern)
      For Each element In elements
         Console.WriteLine(element)
      Next
   End Sub
End Module
' The example displays the following output:
'       abacus
'       alabaster
'       atrium
'       any
'       actual
'       armoir
'       alarm

정규식 패턴 \s-\s?[+*]?\s?-\s은 다음과 같이 정의 됩니다.The regular expression pattern \s-\s?[+*]?\s?-\s is defined like this:

패턴Pattern 설명Description
\s- 하이픈 뒤에 공백 문자를 찾습니다.Match a white-space character followed by a hyphen.
\s? 0번 이상 나오는 공백 문자를 찾습니다.Match zero or one white-space character.
[+*]? 0 번 이상 찾습니다는 + 또는 * 문자입니다.Match zero or one occurrence of either the + or * character.
\s? 0번 이상 나오는 공백 문자를 찾습니다.Match zero or one white-space character.
-\s 공백 문자 뒤에 하이픈을 찾습니다.Match a hyphen followed by a white-space character.

검색 방법 및 Substring 메서드Search methods and the Substring method

문자열의 부분 문자열의 모든 관심이 아닌 경우에 일치 하는 시작 되는 인덱스를 반환 하는 문자열 비교 방법 중 하나를 사용 하는 것이 좋습니다.If you aren't interested in all of the substrings in a string, you might prefer to work with one of the string comparison methods that returns the index at which the match begins. 그런 다음 Substring 메서드를 호출 하 여 원하는 부분 문자열을 추출할 수 있습니다.You can then call the Substring method to extract the substring that you want. 문자열 비교 메서드는 다음과 같습니다.The string comparison methods include:

  • IndexOf는 문자열 인스턴스에서 처음 나타나는 문자 또는 문자열의 0부터 시작 하는 인덱스를 반환 합니다.IndexOf, which returns the zero-based index of the first occurrence of a character or string in a string instance.

  • IndexOfAny-문자 배열에서 첫 번째 문자를 검색 하는 현재 문자열 인스턴스의 인덱스 (0부터 시작)를 반환 합니다.IndexOfAny, which returns the zero-based index in the current string instance of the first occurrence of any character in a character array.

  • LastIndexOf는 문자열 인스턴스에서 마지막으로 발견 되는 문자 또는 문자열의 인덱스 (0부터 시작)를 반환 합니다.LastIndexOf, which returns the zero-based index of the last occurrence of a character or string in a string instance.

  • LastIndexOfAny는 문자 배열에서 마지막으로 나오는 문자에 대 한 현재 문자열 인스턴스의 인덱스 (0부터 시작)를 반환 합니다.LastIndexOfAny, which returns a zero-based index in the current string instance of the last occurrence of any character in a character array.

다음 예제에서는 IndexOf 메서드를 사용 하 여 문자열에서 마침표를 찾습니다.The following example uses the IndexOf method to find the periods in a string. 그런 다음 Substring 메서드를 사용 하 여 전체 문장을 반환 합니다.It then uses the Substring method to return full sentences.

String value = "This is the first sentence in a string. " +
               "More sentences will follow. For example, " +
               "this is the third sentence. This is the " +
               "fourth. And this is the fifth and final " +
               "sentence.";
var sentences = new List<String>();
int position = 0;
int start = 0;
// Extract sentences from the string.
do 
{
   position = value.IndexOf('.', start);
   if (position >= 0) 
   {
      sentences.Add(value.Substring(start, position - start + 1).Trim());
      start = position + 1;
   }
} while (position > 0);

// Display the sentences.
foreach (var sentence in sentences)
   Console.WriteLine(sentence);

// The example displays the following output:
//       This is the first sentence in a string.
//       More sentences will follow.
//       For example, this is the third sentence.
//       This is the fourth.
//       And this is the fifth and final sentence.
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim value As String = "This is the first sentence in a string. " +
                            "More sentences will follow. For example, " +
                            "this is the third sentence. This is the " +
                            "fourth. And this is the fifth and final " +
                            "sentence."
      Dim sentences As New List(Of String)
      Dim position As Integer = 0
      Dim start As Integer = 0
      ' Extract sentences from the string.
      Do
         position = value.IndexOf("."c, start)
         If position >= 0 Then
            sentences.Add(value.Substring(start, position - start + 1).Trim())
            start = position + 1
         End If
      Loop While position > 0
      
      ' Display the sentences.
      For Each sentence In sentences
         Console.WriteLine(sentence)
      Next
   End Sub
End Module
' The example displays the following output:
'       This is the first sentence in a string.
'       More sentences will follow.
'       For example, this is the third sentence.
'       This is the fourth.
'       And this is the fifth and final sentence.

Split(Char[], Int32, StringSplitOptions)

배열에 있는 문자에 따라 최대 개수의 부분 문자열로 문자열을 분할합니다.Splits a string into a maximum number of substrings based on the characters in an array.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (char[] separator, int count, StringSplitOptions options);
member this.Split : char[] * int * StringSplitOptions -> string[]
Public Function Split (separator As Char(), count As Integer, options As StringSplitOptions) As String()

매개 변수

separator
Char[]

이 문자열의 부분 문자열을 구분하는 문자 배열, 구분 기호를 포함하지 않는 빈 배열 또는 null입니다.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32

반환할 부분 문자열의 최대 수입니다.The maximum number of substrings to return.

options
StringSplitOptions

반환된 배열에서 빈 배열 요소를 생략하려면 RemoveEmptyEntries이고, 반환된 배열에 빈 배열 요소를 포함하려면 None입니다.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

반환

String[]

해당 요소에 separator에 있는 하나 이상의 문자로 구분되는 이 문자열의 부분 문자열이 포함된 배열입니다.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. 자세한 내용은 설명 섹션을 참조하세요.For more information, see the Remarks section.

특성

예외

count가 음수입니다.count is negative.

optionsStringSplitOptions 값 중 하나가 아닙니다.options is not one of the StringSplitOptions values.

예제

다음 예제에서는 StringSplitOptions 열거를 사용 하 여 Split 메서드에서 생성 된 부분 문자열을 포함 하거나 제외 합니다.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] {','};
string[] stringSeparators = new string[] {"[stop]"};
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
Console.WriteLine("1a )The original string is \"{0}\".", s1);
Console.WriteLine("The delimiter character is '{0}'.\n", 
                   charSeparators[0]);

// Split a string delimited by characters and return all elements.
Console.WriteLine("1b) Split a string delimited by characters and " +
                  "return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split a string delimited by characters and return all non-empty elements.
Console.WriteLine("1c) Split a string delimited by characters and " +
                  "return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the string and empty string before the 
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("1d) Split a string delimited by characters and " +
                  "return 2 elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
Console.WriteLine("1e) Split a string delimited by characters and " +
                  "return 2 non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
Console.WriteLine("2a) The original string is \"{0}\".", s2);
Console.WriteLine("The delimiter string is \"{0}\".\n", stringSeparators[0]);

// Split a string delimited by another string and return all elements.
Console.WriteLine("2b) Split a string delimited by another string and " +
                  "return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the original string at the delimiter and return all non-empty elements.
Console.WriteLine("2c) Split a string delimited by another string and " +
                  "return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the empty string before the 
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("2d) Split a string delimited by another string and " +
                  "return 2 elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
Console.WriteLine("2e) Split a string delimited by another string and " + 
                  "return 2 non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine("The return value contains these {0} elements:", entries.Length);
    foreach (string entry in entries)
    {
        Console.Write("<{0}>", entry);
    }
    Console.Write("\n\n");
}

/*
This example produces the following results:

1) Split a string delimited by characters:

1a )The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim s1 As String = ",ONE,,TWO,,,THREE,,"
        Dim s2 As String = "[stop]" & _
                           "ONE[stop][stop]" & _
                           "TWO[stop][stop][stop]" & _
                           "THREE[stop][stop]"
        Dim charSeparators() As Char = {","c}
        Dim stringSeparators() As String = {"[stop]"}
        Dim result() As String
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by characters.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
        
        ' Display the original string and delimiter characters.
        Console.WriteLine("1a )The original string is ""{0}"".", s1)
        Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))
        
        ' Split a string delimited by characters and return all elements.
        Console.WriteLine("1b) Split a string delimited by characters and " & _
                          "return all elements:")
        result = s1.Split(charSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split a string delimited by characters and return all non-empty elements.
        Console.WriteLine("1c) Split a string delimited by characters and " & _
                          "return all non-empty elements:")
        result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the string and empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("1d) Split a string delimited by characters and " & _
                          "return 2 elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("1e) Split a string delimited by characters and " & _
                          "return 2 non-empty elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by another string.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)
        
        ' Display the original string and delimiter string.
        Console.WriteLine("2a) The original string is ""{0}"".", s2)
        Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))
        
        ' Split a string delimited by another string and return all elements.
        Console.WriteLine("2b) Split a string delimited by another string and " & _
                          "return all elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string at the delimiter and return all non-empty elements.
        Console.WriteLine("2c) Split a string delimited by another string and " & _
                          "return all non-empty elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("2d) Split a string delimited by another string and " & _
                          "return 2 elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("2e) Split a string delimited by another string and " & _
                          "return 2 non-empty elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
    
    End Sub
    
    
    ' Display the array of separated strings.
    Public Shared Sub Show(ByVal entries() As String) 
        Console.WriteLine("The return value contains these {0} elements:", entries.Length)
        Dim entry As String
        For Each entry In  entries
            Console.Write("<{0}>", entry)
        Next entry
        Console.Write(vbCrLf & vbCrLf)
    
    End Sub
End Class
'
'This example produces the following results:
'
'1) Split a string delimited by characters:
'
'1a )The original string is ",ONE,,TWO,,,THREE,,".
'The delimiter character is ','.
'
'1b) Split a string delimited by characters and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'1c) Split a string delimited by characters and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'1d) Split a string delimited by characters and return 2 elements:
'The return value contains these 2 elements:
'<><ONE,,TWO,,,THREE,,>
'
'1e) Split a string delimited by characters and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO,,,THREE,,>
'
'2) Split a string delimited by another string:
'
'2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'The delimiter string is "[stop]".
'
'2b) Split a string delimited by another string and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'2c) Split a string delimited by another string and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'2d) Split a string delimited by another string and return 2 elements:
'The return value contains these 2 elements:
'<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>
'
'2e) Split a string delimited by another string and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO[stop][stop][stop]THREE[stop][stop]>
'

설명

구분 기호 문자는 반환 된 배열의 요소에 포함 되지 않습니다.Delimiter characters are not included in the elements of the returned array.

이 인스턴스에 separator의 문자가 포함 되어 있지 않거나 count 매개 변수가 1 이면 반환 된 배열은이 인스턴스가 포함 된 단일 요소로 구성 됩니다.If this instance does not contain any of the characters in separator, or the count parameter is 1, the returned array consists of a single element that contains this instance. separator 매개 변수가 null 이거나 문자를 포함 하지 않는 경우 공백 문자는 구분 기호로 간주 됩니다.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. 공백 문자는 유니코드 표준에 의해 정의 되 고 Char.IsWhiteSpace 메서드에 전달 되는 경우 true을 반환 합니다.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. 그러나이 메서드 오버 로드에 대 한 호출의 separator 매개 변수가 null이면 컴파일러 오버 로드 확인이 실패 합니다.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. 호출된 된 메서드를 명확 하 게 식별 하려면 코드는 null의 형식을 나타내야 합니다.To unambiguously identify the called method, your code must indicate the type of the null. 다음 예제에서는이 오버 로드를 명확 하 게 식별 하는 여러 방법을 보여 줍니다.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(Char[]), 3, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split((char[]) null, 3, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split(null as char[], 3, StringSplitOptions.RemoveEmptyEntries);
Dim phrase As String = "The quick brown fox"
Dim words() As String

words = phrase.Split(TryCast(Nothing, Char()), 3, 
                       StringSplitOptions.RemoveEmptyEntries)

words = phrase.Split(New Char() {}, 3,
                     StringSplitOptions.RemoveEmptyEntries)

count 매개 변수가 0 이거나 options 매개 변수가 RemoveEmptyEntries이 고이 인스턴스의 길이가 0 이면 빈 배열이 반환 됩니다.If the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

separator의 각 요소는 별도의 구분 기호 문자를 정의 합니다.Each element of separator defines a separate delimiter character. options 매개 변수가 None고 두 구분 기호가 인접 하거나이 인스턴스의 시작 또는 끝 부분에 구분 기호가 있는 경우 해당 배열 요소에 Empty포함 됩니다.If the options parameter is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

이 인스턴스에 부분 문자열이 count 개 이상 있는 경우 첫 번째 count-1 개의 부분 문자열이 반환 값의 첫 번째 count에서 반환 되 고이 인스턴스의 나머지 문자는 반환 값의 마지막 요소에 반환 됩니다.If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

count이 부분 문자열의 수보다 크면 사용 가능한 부분 문자열이 반환 되 고 예외가 throw 되지 않습니다.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

성능 고려 사항Performance Considerations

Split 메서드는 반환 된 배열 개체에 대해 메모리를 할당 하 고 각 배열 요소에 대해 String 개체를 할당 합니다.The Split methods allocate memory for the returned array object and a String object for each array element. 애플리케이션에 필요한 최적의 성능, 메모리 할당을 관리 하는 것이 중요 애플리케이션 사용을 고려 합니다 IndexOf 또는 IndexOfAny 메서드 및 필요에 따라는 Compare 문자열 내에서 부분 문자열을 찾을 방법입니다.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

구분 문자에서 문자열을 분할 하는 경우 IndexOf 또는 IndexOfAny 메서드를 사용 하 여 문자열에서 구분 기호 문자를 찾습니다.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. 구분 기호 문자열에서 문자열을 분할 하는 경우 IndexOf 또는 IndexOfAny 메서드를 사용 하 여 구분 기호 문자열의 첫 번째 문자를 찾습니다.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. 그런 다음 Compare 메서드를 사용 하 여 첫 번째 문자 뒤의 문자가 구분 기호 문자열의 나머지 문자와 같은지 여부를 확인 합니다.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

또한 여러 Split 메서드 호출에서 문자열을 분할 하는 데 동일한 문자 집합을 사용 하는 경우 단일 배열을 만들고 각 메서드 호출에서 참조 하는 것이 좋습니다.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. 이렇게 하면 각 메서드 호출의 추가 오버 헤드를 크게 줄어듭니다.This significantly reduces the additional overhead of each method call.

호출자 참고

.NET Framework 3.5.NET Framework 3.5 및 이전 버전에서 Split(Char[]) 메서드가 null 되거나 문자를 포함 하지 않는 separator 전달 되는 경우 메서드는 약간 다른 문자 집합을 사용 하 여 문자열을 잘라내는 Trim(Char[]) 메서드가 문자열을 자릅니다.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. .NET Framework 4 부터는 두 방법 모두 유니코드 공백 문자의 동일한 집합을 사용 합니다.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char, Int32, StringSplitOptions)

제공된 문자 구분 기호에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다.Splits a string into a maximum number substrings based on the provided character separator.

public string[] Split (char separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : char * int * StringSplitOptions -> string[]
Public Function Split (separator As Char, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

매개 변수

separator
Char

이 인스턴스에서 부분 문자열을 구분하는 문자입니다.A character that delimits the substrings in this instance.

count
Int32

배열에 필요한 최대 요소 수입니다.The maximum number of elements expected in the array.

options
StringSplitOptions

분할 작업의 반환 값에서 빈 부분 문자열을 생략할지 여부를 결정하는 열거형 값 중 하나입니다.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

반환

String[]

요소에 count로 구분되는 이 인스턴스의 부분 문자열이 separator개 이상 포함된 배열입니다.An array whose elements contain at most count substrings from this instance that are delimited by separator.

설명

문자열이 이미 1 회 count 분할 되었지만 문자열의 끝에 도달 하지 않은 경우 반환 된 배열의 마지막 문자열에는이 인스턴스의 나머지 후행 부분 문자열이 그대로 포함 됩니다.If the string has already been split count - 1 times, but the end of the string has not been reached, then the last string in the returned array will contain this instance's remaining trailing substring, untouched.

Split(String[], Int32, StringSplitOptions)

배열에 있는 문자열에 따라 최대 개수의 부분 문자열로 문자열을 분할합니다.Splits a string into a maximum number of substrings based on the strings in an array. 부분 문자열이 빈 배열 요소를 포함하는지 여부를 지정할 수 있습니다.You can specify whether the substrings include empty array elements.

public:
 cli::array <System::String ^> ^ Split(cli::array <System::String ^> ^ separator, int count, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (string[] separator, int count, StringSplitOptions options);
member this.Split : string[] * int * StringSplitOptions -> string[]
Public Function Split (separator As String(), count As Integer, options As StringSplitOptions) As String()

매개 변수

separator
String[]

이 문자열의 부분 문자열을 구분하는 문자열 배열, 구분 기호를 포함하지 않는 빈 배열 또는 null입니다.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32

반환할 부분 문자열의 최대 수입니다.The maximum number of substrings to return.

options
StringSplitOptions

반환된 배열에서 빈 배열 요소를 생략하려면 RemoveEmptyEntries이고, 반환된 배열에 빈 배열 요소를 포함하려면 None입니다.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

반환

String[]

해당 요소에 separator에 있는 하나 이상의 문자열로 구분되는 이 문자열의 부분 문자열이 포함된 배열입니다.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. 자세한 내용은 설명 섹션을 참조하세요.For more information, see the Remarks section.

특성

예외

count가 음수입니다.count is negative.

optionsStringSplitOptions 값 중 하나가 아닙니다.options is not one of the StringSplitOptions values.

예제

다음 예제에서는 StringSplitOptions 열거를 사용 하 여 Split 메서드에서 생성 된 부분 문자열을 포함 하거나 제외 합니다.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] {','};
string[] stringSeparators = new string[] {"[stop]"};
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
Console.WriteLine("1a )The original string is \"{0}\".", s1);
Console.WriteLine("The delimiter character is '{0}'.\n", 
                   charSeparators[0]);

// Split a string delimited by characters and return all elements.
Console.WriteLine("1b) Split a string delimited by characters and " +
                  "return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split a string delimited by characters and return all non-empty elements.
Console.WriteLine("1c) Split a string delimited by characters and " +
                  "return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the string and empty string before the 
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("1d) Split a string delimited by characters and " +
                  "return 2 elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
Console.WriteLine("1e) Split a string delimited by characters and " +
                  "return 2 non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
Console.WriteLine("2a) The original string is \"{0}\".", s2);
Console.WriteLine("The delimiter string is \"{0}\".\n", stringSeparators[0]);

// Split a string delimited by another string and return all elements.
Console.WriteLine("2b) Split a string delimited by another string and " +
                  "return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the original string at the delimiter and return all non-empty elements.
Console.WriteLine("2c) Split a string delimited by another string and " +
                  "return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the empty string before the 
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("2d) Split a string delimited by another string and " +
                  "return 2 elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
Console.WriteLine("2e) Split a string delimited by another string and " + 
                  "return 2 non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine("The return value contains these {0} elements:", entries.Length);
    foreach (string entry in entries)
    {
        Console.Write("<{0}>", entry);
    }
    Console.Write("\n\n");
}

/*
This example produces the following results:

1) Split a string delimited by characters:

1a )The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim s1 As String = ",ONE,,TWO,,,THREE,,"
        Dim s2 As String = "[stop]" & _
                           "ONE[stop][stop]" & _
                           "TWO[stop][stop][stop]" & _
                           "THREE[stop][stop]"
        Dim charSeparators() As Char = {","c}
        Dim stringSeparators() As String = {"[stop]"}
        Dim result() As String
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by characters.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
        
        ' Display the original string and delimiter characters.
        Console.WriteLine("1a )The original string is ""{0}"".", s1)
        Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))
        
        ' Split a string delimited by characters and return all elements.
        Console.WriteLine("1b) Split a string delimited by characters and " & _
                          "return all elements:")
        result = s1.Split(charSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split a string delimited by characters and return all non-empty elements.
        Console.WriteLine("1c) Split a string delimited by characters and " & _
                          "return all non-empty elements:")
        result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the string and empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("1d) Split a string delimited by characters and " & _
                          "return 2 elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("1e) Split a string delimited by characters and " & _
                          "return 2 non-empty elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by another string.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)
        
        ' Display the original string and delimiter string.
        Console.WriteLine("2a) The original string is ""{0}"".", s2)
        Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))
        
        ' Split a string delimited by another string and return all elements.
        Console.WriteLine("2b) Split a string delimited by another string and " & _
                          "return all elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string at the delimiter and return all non-empty elements.
        Console.WriteLine("2c) Split a string delimited by another string and " & _
                          "return all non-empty elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("2d) Split a string delimited by another string and " & _
                          "return 2 elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("2e) Split a string delimited by another string and " & _
                          "return 2 non-empty elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
    
    End Sub
    
    
    ' Display the array of separated strings.
    Public Shared Sub Show(ByVal entries() As String) 
        Console.WriteLine("The return value contains these {0} elements:", entries.Length)
        Dim entry As String
        For Each entry In  entries
            Console.Write("<{0}>", entry)
        Next entry
        Console.Write(vbCrLf & vbCrLf)
    
    End Sub
End Class
'
'This example produces the following results:
'
'1) Split a string delimited by characters:
'
'1a )The original string is ",ONE,,TWO,,,THREE,,".
'The delimiter character is ','.
'
'1b) Split a string delimited by characters and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'1c) Split a string delimited by characters and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'1d) Split a string delimited by characters and return 2 elements:
'The return value contains these 2 elements:
'<><ONE,,TWO,,,THREE,,>
'
'1e) Split a string delimited by characters and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO,,,THREE,,>
'
'2) Split a string delimited by another string:
'
'2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'The delimiter string is "[stop]".
'
'2b) Split a string delimited by another string and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'2c) Split a string delimited by another string and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'2d) Split a string delimited by another string and return 2 elements:
'The return value contains these 2 elements:
'<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>
'
'2e) Split a string delimited by another string and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO[stop][stop][stop]THREE[stop][stop]>
'

설명

반환 값 정보Return value details

구분 기호 문자열로 반환 된 배열의 요소에 포함 되지 않습니다.Delimiter strings are not included in the elements of the returned array.

이 인스턴스에 separator의 문자열이 포함 되어 있지 않거나 count 매개 변수가 1 이면 반환 된 배열은이 인스턴스가 포함 된 단일 요소로 구성 됩니다.If this instance does not contain any of the strings in separator, or the count parameter is 1, the returned array consists of a single element that contains this instance. separator 매개 변수가 null 이거나 문자를 포함 하지 않는 경우 공백 문자는 구분 기호로 간주 됩니다.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. 공백 문자는 유니코드 표준에 의해 정의 되 고 Char.IsWhiteSpace 메서드에 전달 되는 경우 true을 반환 합니다.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. 그러나이 메서드 오버 로드에 대 한 호출의 separator 매개 변수가 null이면 컴파일러 오버 로드 확인이 실패 합니다.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. 호출 된 메서드를 명확 하 게 식별 하려면 코드에서 null형식을 지정 해야 합니다.To unambiguously identify the called method, your code must indicate the type of the null. 다음 예제에서는이 오버 로드를 명확 하 게 식별 하는 여러 방법을 보여 줍니다.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(string[]), 3, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split((string[]) null, 3, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split(null as string[], 3, StringSplitOptions.RemoveEmptyEntries);
Dim phrase As String = "The quick brown fox"
Dim words() As String

words = phrase.Split(TryCast(Nothing, String()), 3, 
                       StringSplitOptions.RemoveEmptyEntries)

words = phrase.Split(New String() {}, 3,
                     StringSplitOptions.RemoveEmptyEntries)

count 매개 변수가 0 이거나 options 매개 변수가 RemoveEmptyEntries이 고이 인스턴스의 길이가 0 이면 빈 배열이 반환 됩니다.If the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

separator의 각 요소는 하나 이상의 문자로 구성 된 별도의 구분 기호를 정의 합니다.Each element of separator defines a separate delimiter that consists of one or more characters. options 매개 변수가 None고 두 구분 기호가 인접 하거나이 인스턴스의 시작 또는 끝 부분에 구분 기호가 있는 경우 해당 배열 요소에 Empty포함 됩니다.If the options parameter is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

이 인스턴스에 부분 문자열이 count 개 이상 있는 경우 첫 번째 count-1 개의 부분 문자열이 반환 값의 첫 번째 count에서 반환 되 고이 인스턴스의 나머지 문자는 반환 값의 마지막 요소에 반환 됩니다.If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

count이 부분 문자열의 수보다 크면 사용 가능한 부분 문자열이 반환 되 고 예외가 throw 되지 않습니다.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

구분 기호 배열The separator array

separator의 요소가 여러 문자로 구성 된 경우 전체 부분 문자열이 구분 기호로 간주 됩니다.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. 예를 들어 separator의 요소 중 하나가 "10" 인 경우 "This10is10a10string" 문자열을 분할 하려고 시도 합니다.For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." 이 4 개 요소 배열을 반환 합니다: {"This", "is", "a", "문자열입니다."returns this four-element array: { "This", "is", "a", "string." }.}.

비교 세부 정보Comparison details

Split 메서드는 separator 매개 변수에서 하나 이상의 문자열로 구분 되는이 문자열의 부분 문자열을 추출 하 고 해당 부분 문자열을 배열의 요소로 반환 합니다.The Split method extracts the substrings in this string that are delimited by one or more of the strings in the separator parameter, and returns those substrings as elements of an array.

Split 메서드는 대/소문자 구분 서 수 정렬 규칙을 사용 하 여 비교를 수행 하 여 구분 기호를 찾습니다.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. 단어, 문자열 및 서 수 정렬에 대 한 자세한 내용은 System.Globalization.CompareOptions 열거를 참조 하세요.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Split 메서드는 값이 null 이거나 빈 문자열 ("") 인 separator 요소를 무시 합니다.The Split method ignores any element of separator whose value is null or the empty string ("").

separator 문자열에 공통 된 문자가 포함 된 경우 모호한 결과를 방지 하기 위해 Split 메서드는 인스턴스 값의 처음부터 끝까지 진행 되 고 인스턴스의 구분 기호와 같은 separator의 첫 번째 요소와 일치 합니다.To avoid ambiguous results when strings in separator have characters in common, the Split method proceeds from the beginning to the end of the value of the instance, and matches the first element in separator that is equal to a delimiter in the instance. 인스턴스에서 부분 문자열이 발생 하는 순서는 separator의 요소 순서 보다 우선적으로 적용 됩니다.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

예를 들어 값인 "abcdef" 인스턴스에 것이 좋습니다.For example, consider an instance whose value is "abcdef". separator의 첫 번째 요소가 "ef"이 고 두 번째 요소가 "bcde" 인 경우 split 작업의 결과는 "a" 및 "f"가 됩니다.If the first element in separator was "ef" and the second element was "bcde", the result of the split operation would be "a" and "f". 이는 "bcde" 인스턴스의 부분 문자열이 발생 하 고 부분 문자열 "f"가 발생 하기 전에 separator의 요소와 일치 하기 때문입니다.This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

그러나 separator의 첫 번째 요소가 "bcd"이 고 두 번째 요소가 "bc" 인 경우 split 작업의 결과는 "a"와 "ef"가 됩니다.However, if the first element of separator was "bcd" and the second element was "bc", the result of the split operation would be "a" and "ef". "Bcd"는 인스턴스의 구분 기호와 일치 하는 separator의 첫 번째 구분 기호 이기 때문입니다.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. 첫 번째 요소 "bc"는 구분 기호의 순서 거꾸로 되어 있고 두 번째 요소가 "bcd", 결과 "a"와 "def"입니다.If the order of the separators was reversed so the first element was "bc" and the second element was "bcd", the result would be "a" and "def".

성능 고려 사항Performance considerations

Split 메서드는 반환 된 배열 개체에 대해 메모리를 할당 하 고 각 배열 요소에 대해 String 개체를 할당 합니다.The Split methods allocate memory for the returned array object and a String object for each array element. 애플리케이션에 필요한 최적의 성능, 메모리 할당을 관리 하는 것이 중요 애플리케이션 사용을 고려 합니다 IndexOf 또는 IndexOfAny 메서드 및 필요에 따라는 Compare 문자열 내에서 부분 문자열을 찾을 방법입니다.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

구분 문자에서 문자열을 분할 하는 경우 IndexOf 또는 IndexOfAny 메서드를 사용 하 여 문자열에서 구분 기호 문자를 찾습니다.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. 구분 기호 문자열에서 문자열을 분할 하는 경우 IndexOf 또는 IndexOfAny 메서드를 사용 하 여 구분 기호 문자열의 첫 번째 문자를 찾습니다.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. 그런 다음 Compare 메서드를 사용 하 여 첫 번째 문자 뒤의 문자가 구분 기호 문자열의 나머지 문자와 같은지 여부를 확인 합니다.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

또한 여러 Split 메서드 호출에서 문자열을 분할 하는 데 동일한 문자 집합을 사용 하는 경우 단일 배열을 만들고 각 메서드 호출에서 참조 하는 것이 좋습니다.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. 이렇게 하면 각 메서드 호출의 추가 오버 헤드를 크게 줄어듭니다.This significantly reduces the additional overhead of each method call.

호출자 참고

.NET Framework 3.5.NET Framework 3.5 및 이전 버전에서 Split(Char[]) 메서드가 null 되거나 문자를 포함 하지 않는 separator 전달 되는 경우 메서드는 약간 다른 문자 집합을 사용 하 여 문자열을 잘라내는 Trim(Char[]) 메서드가 문자열을 자릅니다.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. .NET Framework 4 부터는 두 방법 모두 유니코드 공백 문자의 동일한 집합을 사용 합니다.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(String[], StringSplitOptions)

배열에 있는 문자열에 따라 문자열을 부분 문자열로 분할합니다.Splits a string into substrings based on the strings in an array. 부분 문자열이 빈 배열 요소를 포함하는지 여부를 지정할 수 있습니다.You can specify whether the substrings include empty array elements.

public:
 cli::array <System::String ^> ^ Split(cli::array <System::String ^> ^ separator, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (string[] separator, StringSplitOptions options);
member this.Split : string[] * StringSplitOptions -> string[]
Public Function Split (separator As String(), options As StringSplitOptions) As String()

매개 변수

separator
String[]

이 문자열의 부분 문자열을 구분하는 문자열 배열, 구분 기호를 포함하지 않는 빈 배열 또는 null입니다.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions

반환된 배열에서 빈 배열 요소를 생략하려면 RemoveEmptyEntries이고, 반환된 배열에 빈 배열 요소를 포함하려면 None입니다.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

반환

String[]

해당 요소에 separator에 있는 하나 이상의 문자열로 구분되는 이 문자열의 부분 문자열이 포함된 배열입니다.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. 자세한 내용은 설명 섹션을 참조하세요.For more information, see the Remarks section.

특성

예외

optionsStringSplitOptions 값 중 하나가 아닙니다.options is not one of the StringSplitOptions values.

예제

다음 예제에서는 문자열의 String.Split(String[], StringSplitOptions) 메서드를 호출 하 여 반환 된 배열의 차이점을 보여 줍니다. options 매개 변수는 StringSplitOptions.NoneStringSplitOptions.RemoveEmptyEntries와 동일 합니다.The following example illustrates the difference in the arrays returned by calling a string's String.Split(String[], StringSplitOptions) method with its options parameter equal to StringSplitOptions.None and StringSplitOptions.RemoveEmptyEntries.

   string source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]";
   string[] stringSeparators = new string[] {"[stop]"};
   string[] result;
   
   // Display the original string and delimiter string.
   Console.WriteLine("Splitting the string:\n   \"{0}\".", source);
   Console.WriteLine();
   Console.WriteLine("Using the delimiter string:\n   \"{0}\"", 
                     stringSeparators[0]);
   Console.WriteLine();                           
      
   // Split a string delimited by another string and return all elements.
   result = source.Split(stringSeparators, StringSplitOptions.None);
   Console.WriteLine("Result including all elements ({0} elements):", 
                     result.Length);
   Console.Write("   ");
   foreach (string s in result)
   {
      Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);                   
   }
   Console.WriteLine();
   Console.WriteLine();

   // Split delimited by another string and return all non-empty elements.
   result = source.Split(stringSeparators, 
                         StringSplitOptions.RemoveEmptyEntries);
   Console.WriteLine("Result including non-empty elements ({0} elements):", 
                     result.Length);
   Console.Write("   ");
   foreach (string s in result)
   {
      Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);                   
   }
   Console.WriteLine();

   // The example displays the following output:
   //    Splitting the string:
   //       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
   //    
   //    Using the delimiter string:
   //       "[stop]"
   //    
   //    Result including all elements (9 elements):
   //       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
   //    
   //    Result including non-empty elements (3 elements):
   //       'ONE' 'TWO' 'THREE'
Module Example
   Public Sub Main()
      Dim source As String = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]"
      Dim stringSeparators() As String = {"[stop]"}
      Dim result() As String
      
      ' Display the original string and delimiter string.
      Console.WriteLine("Splitting the string:{0}   '{1}'.", vbCrLf, source)
      Console.WriteLine()
      Console.WriteLine("Using the delimiter string:{0}   '{1}'.", _
                        vbCrLf, stringSeparators(0))
      Console.WriteLine()                          
         
      ' Split a string delimited by another string and return all elements.
      result = source.Split(stringSeparators, StringSplitOptions.None)
      Console.WriteLine("Result including all elements ({0} elements):", _ 
                        result.Length)
      Console.Write("   ")
      For Each s As String In result
         Console.Write("'{0}' ", IIf(String.IsNullOrEmpty(s), "<>", s))                   
      Next
      Console.WriteLine()
      Console.WriteLine()

      ' Split delimited by another string and return all non-empty elements.
      result = source.Split(stringSeparators, _ 
                            StringSplitOptions.RemoveEmptyEntries)
      Console.WriteLine("Result including non-empty elements ({0} elements):", _ 
                        result.Length)
      Console.Write("   ")
      For Each s As String In result
         Console.Write("'{0}' ", IIf(String.IsNullOrEmpty(s), "<>", s))                   
      Next
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Splitting the string:
'       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'    
'    Using the delimiter string:
'       "[stop]"
'    
'    Result including all elements (9 elements):
'       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
'    
'    Result including non-empty elements (3 elements):
'       'ONE' 'TWO' 'THREE'

다음 예제에서는 문장 부호 및 공백 문자를 포함 하는 구분 기호 배열을 정의 합니다.The following example defines an array of separators that include punctuation and white-space characters. StringSplitOptions.RemoveEmptyEntries 값과 함께이 배열을 Split(String[], StringSplitOptions) 메서드에 전달 하면 문자열의 개별 단어로 구성 된 배열이 반환 됩니다.Passing this array along with a value of StringSplitOptions.RemoveEmptyEntries to the Split(String[], StringSplitOptions) method returns an array that consists of the individual words from the string.

string[] separators = {",", ".", "!", "?", ";", ":", " "};
string value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";
string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var word in words)
   Console.WriteLine(word);
   
// The example displays the following output:
//       The
//       handsome
//       energetic
//       young
//       dog
//       was
//       playing
//       with
//       his
//       smaller
//       more
//       lethargic
//       litter
//       mate
Module Example
   Public Sub Main()
      Dim separators() As String = {",", ".", "!", "?", ";", ":", " "}
      Dim value As String = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate."
      Dim words() As String = value.Split(separators, StringSplitOptions.RemoveEmptyEntries)
      For Each word In words
         Console.WriteLine(word)
      Next   
   End Sub
End Module
' The example displays the following output:
'       The
'       handsome
'       energetic
'       young
'       dog
'       was
'       playing
'       with
'       his
'       smaller
'       more
'       lethargic
'       litter
'       mate

메서드는 StringSplitOptions.RemoveEmptyEntries로 설정 된 options 인수를 사용 하 여 호출 됩니다.Note that the method is called with the options argument set to StringSplitOptions.RemoveEmptyEntries. 이렇게 하면 반환 된 배열에서 문장 부호와 공백 문자 사이의 빈 부분 문자열 일치 항목을 나타내는 String.Empty 값을 포함 하지 않습니다.This prevents the returned array from including String.Empty values that represent empty substring matches between punctuation marks and white-space characters.

설명

문자열이 알려진 문자열 집합으로 구분 되는 경우 Split 메서드를 사용 하 여 해당 문자열을 부분 문자열로 구분할 수 있습니다.When a string is delimited by a known set of strings, you can use the Split method to separate it into substrings.

반환 값 정보Return value details

구분 기호 문자열로 반환 된 배열의 요소에 포함 되지 않습니다.Delimiter strings are not included in the elements of the returned array. 예를 들어 separator 배열에 "--" 문자열이 포함 되어 있고 현재 문자열 인스턴스의 값이 "aa--bc-cc" 인 경우이 메서드는 "aa", "bb" 및 "cc" 라는 세 개의 요소가 포함 된 배열을 반환 합니다.For example, if the separator array includes the string "--" and the value of the current string instance is "aa--bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

이 인스턴스에 separator의 문자열이 포함 되어 있지 않으면 반환 된 배열은이 인스턴스가 포함 된 단일 요소로 구성 됩니다.If this instance does not contain any of the strings in separator, the returned array consists of a single element that contains this instance.

options 매개 변수가 RemoveEmptyEntries이 고이 인스턴스의 길이가 0 인 경우이 메서드는 빈 배열을 반환 합니다.If the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

separator의 각 요소는 하나 이상의 문자로 구성 된 별도의 구분 기호를 정의 합니다.Each element of separator defines a separate delimiter that consists of one or more characters. options 인수를 None하 고 두 구분 기호가 인접 하거나이 인스턴스의 시작 부분 또는 끝 부분에 구분 기호가 있는 경우 해당 배열 요소는 String.Empty을 포함 합니다.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. 예를 들어 separator에 "-" 및 "_" 요소가 포함 된 경우 문자열 인스턴스의 값은 "-_aa-_"이 고 options 인수의 값은 None입니다 .이 메서드는 다음과 같은 5 개의 요소로 문자열 배열을 반환 합니다.For example, if separator includes two elements, "-" and "_", the value of the string instance is "-_aa-_", and the value of the options argument is None, the method returns a sting array with the following five elements:

  1. 인덱스 0에서 "-" 부분 문자열 앞에 오는 빈 문자열을 나타내는 String.Empty입니다.String.Empty, which represents the empty string that precedes the "-" substring at index 0.

  2. String.Empty-인덱스 0의 "-" 부분 문자열과 인덱스 1의 "" 부분 문자열 사이에 빈 문자열을 나타냅니다.String.Empty, which represents the empty string between the "-" substring at index 0 and the "" substring at index 1.

  3. "aa","aa",

  4. 인덱스 4에서 "" 부분 문자열 뒤에 오는 빈 문자열을 나타내는 String.Empty입니다.String.Empty, which represents the empty string that follows the "" substring at index 4.

  5. 인덱스 5에서 "-" 부분 문자열 뒤에 오는 빈 문자열을 나타내는 String.Empty입니다.String.Empty, which represents the empty string that follows the "-" substring at index 5.

구분 기호 배열The separator array

separator의 요소가 여러 문자로 구성 된 경우 전체 부분 문자열이 구분 기호로 간주 됩니다.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. 예를 들어 separator의 요소 중 하나가 "10" 인 경우 "This10is10a10string" 문자열을 분할 하려고 시도 합니다.For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." 다음 4 개 요소 배열을 반환 합니다: {"This", "is", "a", "문자열입니다."returns the following four-element array: { "This", "is", "a", "string." }.}.

separator 매개 변수가 null 이거나 문자를 포함 하지 않는 경우 공백 문자는 구분 기호로 간주 됩니다.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. 공백 문자는 유니코드 표준에 의해 정의 되 고 Char.IsWhiteSpace 메서드에 전달 되는 경우 true을 반환 합니다.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

이 메서드 오버 로드에 대 한 호출의 separator 매개 변수가 null이면 컴파일러 오버 로드 확인이 실패 합니다.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. 호출 된 메서드를 명확 하 게 식별 하려면 코드에서 null형식을 지정 해야 합니다.To unambiguously identify the called method, your code must indicate the type of the null. 다음 예제에서는이 오버 로드를 명확 하 게 식별 하는 여러 방법을 보여 줍니다.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split((string[]) null, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split(null as string[], StringSplitOptions.RemoveEmptyEntries);
Dim phrase As String = "The quick brown fox"
Dim words() As String

words = phrase.Split(TryCast(Nothing, String()),  
                       StringSplitOptions.RemoveEmptyEntries)

words = phrase.Split(New String() {},
                     StringSplitOptions.RemoveEmptyEntries)

비교 세부 정보Comparison details

Split 메서드는 separator 매개 변수에서 하나 이상의 문자열로 구분 되는이 문자열의 부분 문자열을 추출 하 고 해당 부분 문자열을 배열의 요소로 반환 합니다.The Split method extracts the substrings in this string that are delimited by one or more of the strings in the separator parameter, and returns those substrings as elements of an array.

Split 메서드는 대/소문자 구분 서 수 정렬 규칙을 사용 하 여 비교를 수행 하 여 구분 기호를 찾습니다.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. 단어, 문자열 및 서 수 정렬에 대 한 자세한 내용은 System.Globalization.CompareOptions 열거를 참조 하세요.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Split 메서드는 값이 null 이거나 빈 문자열 ("") 인 separator 요소를 무시 합니다.The Split method ignores any element of separator whose value is null or the empty string ("").

separator 문자열에 공통 된 문자가 포함 된 경우 모호한 결과를 방지 하기 위해 Split 작업은 인스턴스 값의 처음부터 끝까지 진행 되 고 인스턴스의 구분 기호와 같은 separator의 첫 번째 요소와 일치 합니다.To avoid ambiguous results when strings in separator have characters in common, the Split operation proceeds from the beginning to the end of the value of the instance, and matches the first element in separator that is equal to a delimiter in the instance. 인스턴스에서 부분 문자열이 발생 하는 순서는 separator의 요소 순서 보다 우선적으로 적용 됩니다.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

예를 들어 값인 "abcdef" 인스턴스에 것이 좋습니다.For example, consider an instance whose value is "abcdef". separator의 첫 번째 요소가 "ef"이 고 두 번째 요소가 "bcde" 인 경우 split 작업의 결과는 "a"와 "f" 라는 두 개의 요소를 포함 하는 문자열 배열입니다.If the first element in separator was "ef" and the second element was "bcde", the result of the split operation would be a string array that contains two elements, "a" and "f". 이는 "bcde" 인스턴스의 부분 문자열이 발생 하 고 부분 문자열 "f"가 발생 하기 전에 separator의 요소와 일치 하기 때문입니다.This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

그러나 separator의 첫 번째 요소가 "bcd"이 고 두 번째 요소가 "bc" 인 경우 split 작업의 결과는 "a"와 "ef" 라는 두 개의 요소를 포함 하는 문자열 배열입니다.However, if the first element of separator was "bcd" and the second element was "bc", the result of the split operation would be a string array that contains two elements, "a" and "ef". "Bcd"는 인스턴스의 구분 기호와 일치 하는 separator의 첫 번째 구분 기호 이기 때문입니다.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. 첫 번째 요소 "bc"는 구분 기호의 순서 거꾸로 되어 및 두 번째 요소가 "bcd" 이면 결과 두 개의 요소를 포함 하는 문자열 배열 하는 경우 "a"와 "def"입니다.If the order of the separators was reversed so the first element was "bc" and the second element was "bcd", the result would be a string array that contains two elements, "a" and "def".

성능 고려 사항Performance considerations

Split 메서드는 반환 된 배열 개체에 대해 메모리를 할당 하 고 각 배열 요소에 대해 String 개체를 할당 합니다.The Split methods allocate memory for the returned array object and a String object for each array element. 애플리케이션에 필요한 최적의 성능, 메모리 할당을 관리 하는 것이 중요 애플리케이션 사용을 고려 합니다 IndexOf 또는 IndexOfAny 메서드 및 필요에 따라는 Compare 문자열 내에서 부분 문자열을 찾을 방법입니다.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

구분 문자에서 문자열을 분할 하는 경우 IndexOf 또는 IndexOfAny 메서드를 사용 하 여 문자열에서 구분 기호 문자를 찾습니다.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. 구분 기호 문자열에서 문자열을 분할 하는 경우 IndexOf 또는 IndexOfAny 메서드를 사용 하 여 구분 기호 문자열의 첫 번째 문자를 찾습니다.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. 그런 다음 Compare 메서드를 사용 하 여 첫 번째 문자 뒤의 문자가 구분 기호 문자열의 나머지 문자와 같은지 여부를 확인 합니다.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

또한 여러 Split 메서드 호출에서 문자열을 분할 하는 데 동일한 문자 집합을 사용 하는 경우 단일 배열을 만들고 각 메서드 호출에서 참조 하는 것이 좋습니다.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. 이렇게 하면 각 메서드 호출의 추가 오버 헤드를 크게 줄어듭니다.This significantly reduces the additional overhead of each method call.

호출자 참고

.NET Framework 3.5.NET Framework 3.5 및 이전 버전에서 Split(Char[]) 메서드가 null 되거나 문자를 포함 하지 않는 separator 전달 되는 경우 메서드는 약간 다른 문자 집합을 사용 하 여 문자열을 잘라내는 Trim(Char[]) 메서드가 문자열을 자릅니다.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. .NET Framework 4 부터는 두 방법 모두 유니코드 공백 문자의 동일한 집합을 사용 합니다.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(String, Int32, StringSplitOptions)

제공된 문자열 구분 기호에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다.Splits a string into a maximum number of substrings based on the provided string separator.

public string[] Split (string separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : string * int * StringSplitOptions -> string[]
Public Function Split (separator As String, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

매개 변수

separator
String

이 인스턴스에서 부분 문자열을 구분하는 문자열입니다.A string that delimits the substrings in this instance.

count
Int32

배열에 필요한 최대 요소 수입니다.The maximum number of elements expected in the array.

options
StringSplitOptions

분할 작업의 반환 값에서 빈 부분 문자열을 생략할지 여부를 결정하는 열거형 값 중 하나입니다.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

반환

String[]

요소에 count로 구분되는 이 인스턴스의 부분 문자열이 separator개 이상 포함된 배열입니다.An array whose elements contain at most count substrings from this instance that are delimited by separator.

설명

문자열이 이미 1 회 count 분할 되었지만 문자열의 끝에 도달 하지 않은 경우 반환 된 배열의 마지막 문자열에는이 인스턴스의 나머지 후행 부분 문자열이 그대로 포함 됩니다.If the string has already been split count - 1 times, but the end of the string has not been reached, then the last string in the returned array will contain this instance's remaining trailing substring, untouched.

Split(Char[], StringSplitOptions)

배열에 있는 문자에 따라 문자열을 부분 문자열로 분할합니다.Splits a string into substrings based on the characters in an array. 부분 문자열이 빈 배열 요소를 포함하는지 여부를 지정할 수 있습니다.You can specify whether the substrings include empty array elements.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (char[] separator, StringSplitOptions options);
member this.Split : char[] * StringSplitOptions -> string[]
Public Function Split (separator As Char(), options As StringSplitOptions) As String()

매개 변수

separator
Char[]

이 문자열의 부분 문자열을 구분하는 문자 배열, 구분 기호를 포함하지 않는 빈 배열 또는 null입니다.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions

반환된 배열에서 빈 배열 요소를 생략하려면 RemoveEmptyEntries이고, 반환된 배열에 빈 배열 요소를 포함하려면 None입니다.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

반환

String[]

해당 요소에 separator에 있는 하나 이상의 문자로 구분되는 이 문자열의 부분 문자열이 포함된 배열입니다.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. 자세한 내용은 설명 섹션을 참조하세요.For more information, see the Remarks section.

특성

예외

optionsStringSplitOptions 값 중 하나가 아닙니다.options is not one of the StringSplitOptions values.

예제

다음 예제에서는 StringSplitOptions 열거를 사용 하 여 Split 메서드에서 생성 된 부분 문자열을 포함 하거나 제외 합니다.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] {','};
string[] stringSeparators = new string[] {"[stop]"};
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
Console.WriteLine("1a )The original string is \"{0}\".", s1);
Console.WriteLine("The delimiter character is '{0}'.\n", 
                   charSeparators[0]);

// Split a string delimited by characters and return all elements.
Console.WriteLine("1b) Split a string delimited by characters and " +
                  "return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split a string delimited by characters and return all non-empty elements.
Console.WriteLine("1c) Split a string delimited by characters and " +
                  "return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the string and empty string before the 
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("1d) Split a string delimited by characters and " +
                  "return 2 elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
Console.WriteLine("1e) Split a string delimited by characters and " +
                  "return 2 non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
Console.WriteLine("2a) The original string is \"{0}\".", s2);
Console.WriteLine("The delimiter string is \"{0}\".\n", stringSeparators[0]);

// Split a string delimited by another string and return all elements.
Console.WriteLine("2b) Split a string delimited by another string and " +
                  "return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the original string at the delimiter and return all non-empty elements.
Console.WriteLine("2c) Split a string delimited by another string and " +
                  "return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the empty string before the 
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("2d) Split a string delimited by another string and " +
                  "return 2 elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
Console.WriteLine("2e) Split a string delimited by another string and " + 
                  "return 2 non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine("The return value contains these {0} elements:", entries.Length);
    foreach (string entry in entries)
    {
        Console.Write("<{0}>", entry);
    }
    Console.Write("\n\n");
}

/*
This example produces the following results:

1) Split a string delimited by characters:

1a )The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim s1 As String = ",ONE,,TWO,,,THREE,,"
        Dim s2 As String = "[stop]" & _
                           "ONE[stop][stop]" & _
                           "TWO[stop][stop][stop]" & _
                           "THREE[stop][stop]"
        Dim charSeparators() As Char = {","c}
        Dim stringSeparators() As String = {"[stop]"}
        Dim result() As String
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by characters.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
        
        ' Display the original string and delimiter characters.
        Console.WriteLine("1a )The original string is ""{0}"".", s1)
        Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))
        
        ' Split a string delimited by characters and return all elements.
        Console.WriteLine("1b) Split a string delimited by characters and " & _
                          "return all elements:")
        result = s1.Split(charSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split a string delimited by characters and return all non-empty elements.
        Console.WriteLine("1c) Split a string delimited by characters and " & _
                          "return all non-empty elements:")
        result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the string and empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("1d) Split a string delimited by characters and " & _
                          "return 2 elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("1e) Split a string delimited by characters and " & _
                          "return 2 non-empty elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by another string.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)
        
        ' Display the original string and delimiter string.
        Console.WriteLine("2a) The original string is ""{0}"".", s2)
        Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))
        
        ' Split a string delimited by another string and return all elements.
        Console.WriteLine("2b) Split a string delimited by another string and " & _
                          "return all elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string at the delimiter and return all non-empty elements.
        Console.WriteLine("2c) Split a string delimited by another string and " & _
                          "return all non-empty elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("2d) Split a string delimited by another string and " & _
                          "return 2 elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("2e) Split a string delimited by another string and " & _
                          "return 2 non-empty elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
    
    End Sub
    
    
    ' Display the array of separated strings.
    Public Shared Sub Show(ByVal entries() As String) 
        Console.WriteLine("The return value contains these {0} elements:", entries.Length)
        Dim entry As String
        For Each entry In  entries
            Console.Write("<{0}>", entry)
        Next entry
        Console.Write(vbCrLf & vbCrLf)
    
    End Sub
End Class
'
'This example produces the following results:
'
'1) Split a string delimited by characters:
'
'1a )The original string is ",ONE,,TWO,,,THREE,,".
'The delimiter character is ','.
'
'1b) Split a string delimited by characters and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'1c) Split a string delimited by characters and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'1d) Split a string delimited by characters and return 2 elements:
'The return value contains these 2 elements:
'<><ONE,,TWO,,,THREE,,>
'
'1e) Split a string delimited by characters and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO,,,THREE,,>
'
'2) Split a string delimited by another string:
'
'2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'The delimiter string is "[stop]".
'
'2b) Split a string delimited by another string and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'2c) Split a string delimited by another string and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'2d) Split a string delimited by another string and return 2 elements:
'The return value contains these 2 elements:
'<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>
'
'2e) Split a string delimited by another string and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO[stop][stop][stop]THREE[stop][stop]>
'

설명

반환 값 정보Return value details

구분 기호 문자 (separator 배열의 문자)는 반환 된 배열의 요소에 포함 되지 않습니다.Delimiter characters (the characters in the separator array) are not included in the elements of the returned array. 예를 들어 separator 배열에 "-" 문자가 포함 되 고 현재 문자열 인스턴스의 값이 "aa-bb-cc" 인 경우이 메서드는 "aa", "bb" 및 "cc" 라는 세 개의 요소가 포함 된 배열을 반환 합니다.For example, if the separator array includes the character "-" and the value of the current string instance is "aa-bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

이 인스턴스에 separator의 문자가 포함 되어 있지 않으면 반환 된 배열은이 인스턴스가 포함 된 단일 요소로 구성 됩니다.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

options 매개 변수가 RemoveEmptyEntries이 고이 인스턴스의 길이가 0 인 경우이 메서드는 빈 배열을 반환 합니다.If the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

separator의 각 요소는 단일 문자로 구성 된 별도의 구분 기호를 정의 합니다.Each element of separator defines a separate delimiter that consists of a single character. options 인수를 None하 고 두 구분 기호가 인접 하거나이 인스턴스의 시작 부분 또는 끝 부분에 구분 기호가 있는 경우 해당 배열 요소는 String.Empty을 포함 합니다.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. 예를 들어 separator에 "-" 및 "_" 요소가 포함 된 경우 문자열 인스턴스의 값은 "-_aa-_"이 고 options 인수의 값은 None입니다 .이 메서드는 다음과 같은 5 개의 요소를 포함 하는 문자열 배열을 반환 합니다.For example, if separator includes two elements, "-" and "_", the value of the string instance is "-_aa-_", and the value of the options argument is None, the method returns a string array with the following five elements:

  1. 인덱스 0에서 "-" 문자 앞에 오는 빈 문자열을 나타내는 String.Empty입니다.String.Empty, which represents the empty string that precedes the "-" character at index 0.

  2. String.Empty-인덱스 0의 "-" 문자와 인덱스 1의 "" 문자 사이에 있는 빈 문자열을 나타냅니다.String.Empty, which represents the empty string between the "-" character at index 0 and the "" character at index 1.

  3. "aa","aa",

  4. 인덱스 4에서 "" 문자 뒤에 오는 빈 문자열을 나타내는 String.Empty입니다.String.Empty, which represents the empty string that follows the "" character at index 4.

  5. 인덱스 5에서 "-" 문자 뒤에 오는 빈 문자열을 나타내는 String.Empty입니다.String.Empty, which represents the empty string that follows the "-" character at index 5.

구분 기호 배열The separator array

separator 매개 변수가 null 이거나 문자를 포함 하지 않는 경우 공백 문자는 구분 기호로 간주 됩니다.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. 공백 문자는 유니코드 표준에 의해 정의 되 고 Char.IsWhiteSpace 메서드에 전달 되는 경우 true을 반환 합니다.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

이 메서드 오버 로드에 대 한 호출의 separator 매개 변수가 null이면 컴파일러 오버 로드 확인이 실패 합니다.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. 호출 된 메서드를 명확 하 게 식별 하려면 코드에서 null형식을 지정 해야 합니다.To unambiguously identify the called method, your code must indicate the type of the null. 다음 예제에서는이 오버 로드를 명확 하 게 식별 하는 여러 방법을 보여 줍니다.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(Char[]), StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split((char[]) null, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split(null as char[], StringSplitOptions.RemoveEmptyEntries);
Dim phrase As String = "The quick brown fox"
Dim words() As String

words = phrase.Split(TryCast(Nothing, Char()),  
                       StringSplitOptions.RemoveEmptyEntries)

words = phrase.Split(New Char() {}, 
                     StringSplitOptions.RemoveEmptyEntries)

비교 세부 정보Comparison details

Split 메서드는 separator 매개 변수에서 하나 이상의 문자로 구분 되는이 문자열의 부분 문자열을 추출 하 고 해당 부분 문자열을 배열의 요소로 반환 합니다.The Split method extracts the substrings in this string that are delimited by one or more of the characters in the separator parameter, and returns those substrings as elements of an array.

Split 메서드는 대/소문자 구분 서 수 정렬 규칙을 사용 하 여 비교를 수행 하 여 구분 기호를 찾습니다.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. 단어, 문자열 및 서 수 정렬에 대 한 자세한 내용은 System.Globalization.CompareOptions 열거를 참조 하세요.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

성능 고려 사항Performance Considerations

Split 메서드는 반환 된 배열 개체에 대해 메모리를 할당 하 고 각 배열 요소에 대해 String 개체를 할당 합니다.The Split methods allocate memory for the returned array object and a String object for each array element. 애플리케이션에 필요한 최적의 성능, 메모리 할당을 관리 하는 것이 중요 애플리케이션 사용을 고려 합니다 IndexOf 또는 IndexOfAny 메서드 및 필요에 따라는 Compare 문자열 내에서 부분 문자열을 찾을 방법입니다.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

구분 문자에서 문자열을 분할 하는 경우 IndexOf 또는 IndexOfAny 메서드를 사용 하 여 문자열에서 구분 기호 문자를 찾습니다.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. 구분 기호 문자열에서 문자열을 분할 하는 경우 IndexOf 또는 IndexOfAny 메서드를 사용 하 여 구분 기호 문자열의 첫 번째 문자를 찾습니다.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. 그런 다음 Compare 메서드를 사용 하 여 첫 번째 문자 뒤의 문자가 구분 기호 문자열의 나머지 문자와 같은지 여부를 확인 합니다.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

또한 여러 Split 메서드 호출에서 문자열을 분할 하는 데 동일한 문자 집합을 사용 하는 경우 단일 배열을 만들고 각 메서드 호출에서 참조 하는 것이 좋습니다.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. 이렇게 하면 각 메서드 호출의 추가 오버 헤드를 크게 줄어듭니다.This significantly reduces the additional overhead of each method call.

호출자 참고

.NET Framework 3.5.NET Framework 3.5 및 이전 버전에서 Split(Char[]) 메서드가 null 되거나 문자를 포함 하지 않는 separator 전달 되는 경우 메서드는 약간 다른 문자 집합을 사용 하 여 문자열을 잘라내는 Trim(Char[]) 메서드가 문자열을 자릅니다.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. .NET Framework 4 부터는 두 방법 모두 유니코드 공백 문자의 동일한 집합을 사용 합니다.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char[], Int32)

배열에 있는 문자에 따라 최대 개수의 부분 문자열로 문자열을 분할합니다.Splits a string into a maximum number of substrings based on the characters in an array. 반환할 부분 문자열의 최대 수도 지정합니다.You also specify the maximum number of substrings to return.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count);
public string[] Split (char[] separator, int count);
member this.Split : char[] * int -> string[]
Public Function Split (separator As Char(), count As Integer) As String()

매개 변수

separator
Char[]

이 문자열의 부분 문자열을 구분하는 문자 배열, 구분 기호를 포함하지 않는 빈 배열 또는 null입니다.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32

반환할 부분 문자열의 최대 수입니다.The maximum number of substrings to return.

반환

String[]

해당 요소에 separator에 있는 하나 이상의 문자로 구분되는 이 인스턴스의 부분 문자열이 포함된 배열입니다.An array whose elements contain the substrings in this instance that are delimited by one or more characters in separator. 자세한 내용은 설명 섹션을 참조하세요.For more information, see the Remarks section.

예외

count가 음수입니다.count is negative.

예제

다음 예에서는 count Split에서 반환 된 문자열의 수에 영향을 주는 방법을 보여 줍니다.The following example demonstrates how count affects the number of strings returned by Split.

string delimStr = " ,.:";
char [] delimiter = delimStr.ToCharArray();
string words = "one two,three:four.";
string [] split = null;

Console.WriteLine("The delimiters are -{0}-", delimStr);
for (int x = 1; x <= 5; x++) 
{
   split = words.Split(delimiter, x);
   Console.WriteLine("\ncount = {0,2} ..............", x);
   foreach (var s in split) 
   {
       Console.WriteLine("-{0}-", s);
   }
}

// The example displays the following output:
//       The delimiters are - ,.:-
//       count =  1 ..............
//       -one two,three:four.-
//       count =  2 ..............
//       -one-
//       -two,three:four.-
//       count =  3 ..............
//       -one-
//       -two-
//       -three:four.-
//       count =  4 ..............
//       -one-
//       -two-
//       -three-
//       -four.-
//       count =  5 ..............
//       -one-
//       -two-
//       -three-
//       -four-
//       --
Public Class StringSplit2
   Public Shared Sub Main()
      
      Dim delimStr As String = " ,.:"
      Dim delimiter As Char() = delimStr.ToCharArray()
      Dim words As String = "one two,three:four."
      Dim split As String() = Nothing
      
      Console.WriteLine("The delimiters are -{0}-", delimStr)
      Dim x As Integer
      For x = 1 To 5
         split = words.Split(delimiter, x)
         Console.WriteLine(ControlChars.Cr + "count = {0,2} ..............", x)
         Dim s As String
         For Each s In  split
            Console.WriteLine("-{0}-", s)
         Next s
      Next x
   End Sub 
End Class 
' The example displays the following output:
'       The delimiters are - ,.:-
'       count =  1 ..............
'       -one two,three:four.-
'       count =  2 ..............
'       -one-
'       -two,three:four.-
'       count =  3 ..............
'       -one-
'       -two-
'       -three:four.-
'       count =  4 ..............
'       -one-
'       -two-
'       -three-
'       -four.-
'       count =  5 ..............
'       -one-
'       -two-
'       -three-
'       -four-
'       --

설명

구분 기호 문자는 반환 된 배열의 요소에 포함 되지 않습니다.Delimiter characters are not included in the elements of the returned array.

이 인스턴스에 separator의 문자가 포함 되어 있지 않으면 반환 된 배열은이 인스턴스가 포함 된 단일 요소로 구성 됩니다.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance. count 0 이면 빈 배열이 반환 됩니다.If count is zero, an empty array is returned.

separator 매개 변수가 null 이거나 문자를 포함 하지 않는 경우 공백 문자는 구분 기호로 간주 됩니다.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. 공백 문자는 유니코드 표준에 의해 정의 되 고 Char.IsWhiteSpace 메서드에 전달 되는 경우 true을 반환 합니다.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

separator의 각 요소는 별도의 구분 기호 문자를 정의 합니다.Each element of separator defines a separate delimiter character. 두 구분 기호가 인접 하거나이 인스턴스의 시작 부분 또는 끝 부분에 구분 기호가 있는 경우 해당 배열 요소에 Empty포함 됩니다.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

이 인스턴스에 부분 문자열이 count 개 이상 있는 경우 첫 번째 count-1 개의 부분 문자열이 반환 값의 첫 번째 count에서 반환 되 고이 인스턴스의 나머지 문자는 반환 값의 마지막 요소에 반환 됩니다.If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

count이 부분 문자열의 수보다 크면 사용 가능한 부분 문자열이 반환 되 고 예외가 throw 되지 않습니다.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

다음 표에서 예제를 제공합니다.The following table provides examples.

문자열 값String value 구분 기호Separator 개수Count 반환 된 배열Returned array
"42, 12, 19""42, 12, 19" new Char {',', ' '} (C#)new Char[] {',', ' '} (C#)

Char () = {"," c "" c} (Visual Basic)Char() = {","c, " "c} (Visual Basic)
22 {"42", " 12, 19"}{"42", " 12, 19"}
"42..12..19""42..12..19" new 문자 {0} '.'}new Char[] {'.'} (C#)(C#)

Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)
44 {"42", "", "12", ".19"}{"42", "", "12", ".19"}
"Banana""Banana" new 문자 {0} '.'}new Char[] {'.'} (C#)(C#)

Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)
22 {"Banana"}{"Banana"}
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
new Char [] {} (C#)new Char[] {} (C#)

Char () = {} (Visual Basic)Char() = {} (Visual Basic)
11 {"Darb\nSmarba"} (C#){"Darb\nSmarba"} (C#)

"Darb" vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
null new Char (C#)new Char[] null (C#)

Char () = NothingChar() = Nothing
22 {"Darb", "Smarba"}{"Darb", "Smarba"}
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
null new Char (C#)new Char[] null (C#)

Char () = NothingChar() = Nothing
100100 {"Darb", "Smarba"}{"Darb", "Smarba"}

성능 고려 사항Performance Considerations

Split 메서드는 반환 된 배열 개체에 대해 메모리를 할당 하 고 각 배열 요소에 대해 String 개체를 할당 합니다.The Split methods allocate memory for the returned array object and a String object for each array element. 애플리케이션에 필요한 최적의 성능, 메모리 할당을 관리 하는 것이 중요 애플리케이션 사용을 고려 합니다 IndexOf 또는 IndexOfAny 메서드 및 필요에 따라는 Compare 문자열 내에서 부분 문자열을 찾을 방법입니다.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

구분 문자에서 문자열을 분할 하는 경우 IndexOf 또는 IndexOfAny 메서드를 사용 하 여 문자열에서 구분 기호 문자를 찾습니다.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. 구분 기호 문자열에서 문자열을 분할 하는 경우 IndexOf 또는 IndexOfAny 메서드를 사용 하 여 구분 기호 문자열의 첫 번째 문자를 찾습니다.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. 그런 다음 Compare 메서드를 사용 하 여 첫 번째 문자 뒤의 문자가 구분 기호 문자열의 나머지 문자와 같은지 여부를 확인 합니다.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

또한 여러 Split 메서드 호출에서 문자열을 분할 하는 데 동일한 문자 집합을 사용 하는 경우 단일 배열을 만들고 각 메서드 호출에서 참조 하는 것이 좋습니다.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. 이렇게 하면 각 메서드 호출의 추가 오버 헤드를 크게 줄어듭니다.This significantly reduces the additional overhead of each method call.

호출자 참고

.NET Framework 3.5.NET Framework 3.5 및 이전 버전에서 Split(Char[]) 메서드가 null 되거나 문자를 포함 하지 않는 separator 전달 되는 경우 메서드는 약간 다른 문자 집합을 사용 하 여 문자열을 잘라내는 Trim(Char[]) 메서드가 문자열을 자릅니다.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. .NET Framework 4 부터는 두 방법 모두 유니코드 공백 문자의 동일한 집합을 사용 합니다.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

추가 정보

Split(Char, StringSplitOptions)

제공된 문자 구분 기호에 따라 문자열을 부분 문자열로 분할합니다.Splits a string into substrings based on the provided character separator.

public string[] Split (char separator, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : char * StringSplitOptions -> string[]
Public Function Split (separator As Char, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

매개 변수

separator
Char

이 문자열에서 부분 문자열을 구분하는 문자입니다.A character that delimits the substrings in this string.

options
StringSplitOptions

분할 작업의 반환 값에서 빈 부분 문자열을 생략할지 여부를 결정하는 열거형 값 중 하나입니다.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

반환

String[]

요소에 separator로 구분되는 이 인스턴스의 부분 문자열이 포함된 배열입니다.An array whose elements contain the substrings from this instance that are delimited by separator.

Split(String, StringSplitOptions)

문자열을 제공된 문자열 구분 기호에 기초하는 부분 문자열로 분할합니다.Splits a string into substrings that are based on the provided string separator.

public string[] Split (string separator, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : string * StringSplitOptions -> string[]
Public Function Split (separator As String, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

매개 변수

separator
String

이 문자열에서 부분 문자열을 구분하는 문자열입니다.A string that delimits the substrings in this string.

options
StringSplitOptions

분할 작업의 반환 값에서 빈 부분 문자열을 생략할지 여부를 결정하는 열거형 값 중 하나입니다.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

반환

String[]

요소에 separator로 구분되는 이 인스턴스의 부분 문자열이 포함된 배열입니다.An array whose elements contain the substrings from this instance that are delimited by separator.

Split(Char[])

문자열을 구분 기호 배열 내 문자에 기초하는 부분 문자열로 분할합니다.Splits a string into substrings that are based on the characters in the separator array.

public:
 cli::array <System::String ^> ^ Split(... cli::array <char> ^ separator);
public string[] Split (params char[] separator);
member this.Split : char[] -> string[]
Public Function Split (ParamArray separator As Char()) As String()

매개 변수

separator
Char[]

이 문자열의 부분 문자열을 구분하는 문자 배열, 구분 기호를 포함하지 않는 빈 배열 또는 null입니다.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

반환

String[]

요소에 separator에 있는 하나 이상의 문자로 구분되는 이 인스턴스의 부분 문자열이 포함된 배열입니다.An array whose elements contain the substrings from this instance that are delimited by one or more characters in separator. 자세한 내용은 설명 섹션을 참조하세요.For more information, see the Remarks section.

예제

다음 예제에서는 구분 기호로 공백 및 문장 부호를 처리 하 여 텍스트 블록에서 개별 단어를 추출 하는 방법에 설명 합니다.The following example demonstrates how to extract individual words from a block of text by treating white space and punctuation marks as delimiters. String.Split(Char[]) 메서드의 separator 매개 변수에 전달 되는 문자 배열은 몇 가지 일반적인 문장 부호 기호와 함께 공백 문자 및 탭 문자로 구성 됩니다.The character array passed to the separator parameter of the String.Split(Char[]) method consists of a space character and a tab character, together with some common punctuation symbols.

string words = "This is a list of words, with: a bit of punctuation" +
               "\tand a tab character.";

string [] split = words.Split(new Char [] {' ', ',', '.', ':', '\t' });

foreach (string s in split) 
{

    if (s.Trim() != "")
        Console.WriteLine(s);
}

// The example displays the following output to the console:
//       This
//       is
//       a
//       list
//       of
//       words
//       with
//       a
//       bit
//       of
//       punctuation
//       and
//       a
//       tab
//       character
Public Class SplitTest
    Public Shared Sub Main()
        Dim words As String = "This is a list of words, with: a bit of punctuation" + _
                              vbTab + "and a tab character."
        Dim split As String() = words.Split(New [Char]() {" "c, ","c, "."c, ":"c, CChar(vbTab) })
                
        For Each s As String In  split
            If s.Trim() <> "" Then
                Console.WriteLine(s)
            End If
        Next s
    End Sub
End Class
' The example displays the following output to the console:
'       This
'       is
'       a
'       list
'       of
'       words
'       with
'       a
'       bit
'       of
'       punctuation
'       and
'       a
'       tab
'       character

설명

문자열이 알려진 문자 집합으로 구분 되는 경우 Split(Char[]) 메서드를 사용 하 여 해당 문자열을 부분 문자열로 구분할 수 있습니다.When a string is delimited by a known set of characters, you can use the Split(Char[]) method to separate it into substrings.

반환 값 정보Return value details

구분 기호 문자는 반환 된 배열의 요소에 포함 되지 않습니다.Delimiter characters are not included in the elements of the returned array. 예를 들어, 배열 구분 기호 문자를 포함 하는 경우 "-"는 현재 문자열 인스턴스가의 값은 "cc-aa-bb", 메서드 3 개 요소가 포함 된 배열을 반환 하 고: "aa", "bb" 및 "cc"입니다.For example, if the separator array includes the character "-" and the value of the current string instance is "aa-bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

이 인스턴스에 separator의 문자가 포함 되어 있지 않으면 반환 된 배열은이 인스턴스가 포함 된 단일 요소로 구성 됩니다.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

separator의 각 요소는 별도의 구분 기호 문자를 정의 합니다.Each element of separator defines a separate delimiter character. 두 구분 기호가 인접 하거나이 인스턴스의 시작 부분 또는 끝 부분에 구분 기호가 있는 경우 반환 된 배열의 해당 요소는 Empty을 포함 합니다.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding element in the returned array contains Empty. 다음은 몇 가지 예입니다.Here are some examples:

문자열 값String value 구분 기호Separator 반환 된 배열Returned array
"42, 12, 19""42, 12, 19" new Char {',', ' '} (C#)new Char[] {',', ' '} (C#)

Char () = {"," c "" c}) (Visual Basic)Char() = {","c, " "c}) (Visual Basic)
{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
"42..12..19""42..12..19" new 문자 {0} '.'}new Char[] {'.'} (C#)(C#)

Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)
{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
"Banana""Banana" new 문자 {0} '.'}new Char[] {'.'} (C#)(C#)

Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)
{"Banana"}{"Banana"}
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
new Char [] {} (C#)new Char[] {} (C#)

Char () = {} (Visual Basic)Char() = {} (Visual Basic)
{"Darb", "Smarba"}{"Darb", "Smarba"}
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
null(C#)null (C#)

Nothing(Visual Basic)Nothing (Visual Basic)
{"Darb", "Smarba"}{"Darb", "Smarba"}

구분 기호 배열The separator array

각 요소의 구분 기호는 단일 문자로 구성 된 별도 구분 기호를 정의 합니다.Each element of separator defines a separate delimiter that consists of a single character. separator 인수가 null 이거나 문자를 포함 하지 않는 경우 메서드는 공백 문자를 구분 기호로 처리 합니다.If the separator argument is null or contains no characters, the method treats white-space characters as the delimiters. 공백 문자는 유니코드 표준에 의해 정의 됩니다. Char.IsWhiteSpace 메서드에 전달 되는 경우 true를 반환 합니다.White-space characters are defined by the Unicode standard; they return true if they are passed to the Char.IsWhiteSpace method.

String.Split(Char[]) 및 컴파일러 오버 로드 확인String.Split(Char[]) and compiler overload resolution

String.Split 오버 로드에 대 한 단일 매개 변수는 문자 배열 이지만 다음 예제에 나와 있는 것 처럼 단일 문자를 사용 하 여 호출할 수 있습니다.Although the single parameter for this overload of String.Split is a character array, you can call it with a single character, as the following example shows.

String value = "This is a short string.";
Char delimiter = 's';
String[] substrings = value.Split(delimiter);
foreach (var substring in substrings)
   Console.WriteLine(substring);
// The example displays the following output:
//     Thi
//      i
//      a
//     hort
//     tring.
Module Example
   Public Sub Main()
      Dim value As String = "This is a short string."
      Dim delimiter As Char = "s"c
      Dim substrings() As String = value.Split(delimiter)
      For Each substring In substrings
         Console.WriteLine(substring)
      Next
   End Sub
End Module
' The example displays the following output:
'     Thi
'      i
'      a
'     hort
'     tring.

separator 매개 변수는 ParamArrayAttribute 특성으로 데코레이팅 되므로 컴파일러는 단일 문자를 단일 요소 문자 배열로 해석 합니다.Because the separator parameter is decorated with the ParamArrayAttribute attribute, compilers will interpret a single character as a single-element character array. 이는 separator 매개 변수를 포함 하는 다른 String.Split 오버 로드의 경우에는 그렇지 않습니다. 이러한 오버 로드는 문자 배열을 separator 인수로 명시적으로 전달 해야 합니다.This is not the case for other String.Split overloads that include a separator parameter; you must explicitly pass these overloads a character array as the separator argument.

비교 세부 정보Comparison details

Split(Char[]) 메서드는 separator 배열에 있는 하나 이상의 문자로 구분 되는이 문자열의 부분 문자열을 추출 하 고 해당 부분 문자열을 배열의 요소로 반환 합니다.The Split(Char[]) method extracts the substrings in this string that are delimited by one or more of the characters in the separator array, and returns those substrings as elements of an array.

Split(Char[]) 메서드는 대/소문자 구분 서 수 정렬 규칙을 사용 하 여 비교를 수행 하 여 구분 기호를 찾습니다.The Split(Char[]) method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. 단어, 문자열 및 서 수 정렬에 대 한 자세한 내용은 System.Globalization.CompareOptions 열거를 참조 하세요.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

성능 고려 사항Performance Considerations

Split 메서드는 반환 된 배열 개체에 대해 메모리를 할당 하 고 각 배열 요소에 대해 String 개체를 할당 합니다.The Split methods allocate memory for the returned array object and a String object for each array element. 애플리케이션에 필요한 최적의 성능, 메모리 할당을 관리 하는 것이 중요 애플리케이션 사용을 고려 합니다 IndexOf 또는 IndexOfAny 메서드.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method. 또한 Compare 메서드를 사용 하 여 문자열 내에서 부분 문자열을 찾는 옵션도 있습니다.You also have the option of using the Compare method to locate a substring within a string.

구분 문자에서 문자열을 분할 하려면 IndexOf 또는 IndexOfAny 메서드를 사용 하 여 문자열에서 구분 문자를 찾습니다.To split a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. 구분 기호 문자열에서 문자열을 분할 하려면 IndexOf 또는 IndexOfAny 메서드를 사용 하 여 구분 기호 문자열의 첫 번째 문자를 찾습니다.To split a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. 그런 다음 Compare 메서드를 사용 하 여 첫 번째 문자 뒤의 문자가 구분 기호 문자열의 나머지 문자와 같은지 여부를 확인 합니다.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

또한 여러 Split 메서드 호출에서 문자열을 분할 하는 데 동일한 문자 집합을 사용 하는 경우 단일 배열을 만들고 각 메서드 호출에서 참조 하는 것이 좋습니다.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. 이렇게 하면 각 메서드 호출의 추가 오버 헤드를 크게 줄어듭니다.This significantly reduces the additional overhead of each method call.

호출자 참고

.NET Framework 3.5.NET Framework 3.5 및 이전 버전에서 Split(Char[]) 메서드가 null 되거나 문자를 포함 하지 않는 separator 전달 되는 경우 메서드는 약간 다른 문자 집합을 사용 하 여 문자열을 잘라내는 Trim(Char[]) 메서드가 문자열을 자릅니다.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. .NET Framework 4 부터는 두 방법 모두 유니코드 공백 문자의 동일한 집합을 사용 합니다.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

추가 정보

적용 대상