String.Split 메서드

정의

지정된 문자열 또는 유니코드 문자 배열의 요소로 구분된 이 인스턴스의 부분 문자열이 포함된 문자열 배열을 반환합니다.

오버로드

Split(Char, Int32, StringSplitOptions)

지정된 구분 문자 및 옵션(필요에 따라)에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다. 제공된 문자 구분 기호에 따라 문자열을 최대 개수의 부분 문자열로 분할하고 필요에 따라 결과에서 빈 부분 문자열을 생략합니다.

Split(String[], Int32, StringSplitOptions)

지정된 구분 문자열 및 옵션(필요에 따라)에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다.

Split(Char[], Int32, StringSplitOptions)

지정된 구분 문자 및 옵션(필요에 따라)에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다.

Split(String[], StringSplitOptions)

지정된 구분 문자열 및 옵션(필요에 따라)에 따라 문자열을 부분 문자열로 분할합니다.

Split(String, Int32, StringSplitOptions)

지정된 구분 문자열 및 옵션(필요에 따라)에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다.

Split(Char[], StringSplitOptions)

지정된 구분 문자 및 옵션에 따라 문자열을 부분 문자열로 분할합니다.

Split(Char[], Int32)

지정된 구분 문자에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다.

Split(Char, StringSplitOptions)

지정된 구분 문자 및 옵션(필요에 따라)에 따라 문자열을 부분 문자열로 분할합니다.

Split(String, StringSplitOptions)

문자열을 제공된 문자열 구분 기호에 기초하는 부분 문자열로 분할합니다.

Split(Char[])

지정된 구분 문자에 따라 문자열을 부분 문자열로 분할합니다.

설명

Split 는 구분 된 문자열을 부분 문자열로 구분 하는 데 사용 됩니다. 문자 배열 또는 문자열 배열 중 하나를 사용 하 여 0 개 이상의 구분 문자 또는 문자열을 지정할 수 있습니다. 구분 문자를 지정 하지 않으면 문자열이 공백 문자로 분할 됩니다.

메서드의 오버 로드를 Split 사용 하면 메서드 (메서드)에서 반환 되는 부분 문자열의 수를 제한 하 Split(Char[], Int32) 고, 결과에 빈 문자열을 포함할지 아니면 부분 문자열을 잘라낼 지를 지정 Split(Char[], StringSplitOptions) Split(String[], StringSplitOptions) 하거나 (및 메서드) 둘 다 ( Split(Char[], Int32, StringSplitOptions)Split(String[], Int32, StringSplitOptions) 메서드)를 수행할 수 있습니다.

Split메서드는 구분 된 문자열을 부분 문자열로 분리 하는 것이 항상 가장 좋은 방법은 아닙니다. 구분 기호로 분리 된 문자열의 부분 문자열을 모두 추출 하지 않으려는 경우 또는 구분 문자 집합 대신 패턴을 기반으로 문자열을 구문 분석 하려는 경우 정규식 사용을 고려 하거나 문자 인덱스를 반환 하는 검색 메서드 중 하나를 메서드와 결합 합니다 Substring . 자세한 내용은 문자열에서 부분 문자열 추출을 참조 하세요.

예제

다음 예제는 String.Split()의 세 가지 오버로드를 보여 줍니다. 첫 번째 예제에서는 Split(Char[]) 오버 로드를 호출 하 고 단일 구분 기호를 전달 합니다.

string s = "You win some. You lose some.";

string[] subs = s.Split(' ');

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some.
// Substring: You
// Substring: lose
// Substring: some.

여기에서 볼 수 있듯이 마침표 문자(.)가 두 부분 문자열에 포함됩니다. 마침표 문자를 제외하려는 경우 마침표 문자를 추가 구분 문자로 추가할 수 있습니다. 다음 예제는 이 작업을 수행하는 방법을 보여 줍니다.

string s = "You win some. You lose some.";

string[] subs = s.Split(' ', '.');

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring:
// Substring: You
// Substring: lose
// Substring: some
// Substring:

부분 문자열에서 마침표가 사라졌지만 이제는 두 개의 빈 부분 문자열이 추가로 포함되었습니다. 이러한 빈 부분 문자열은 단어와 그 뒤에 오는 마침표 사이의 부분 문자열을 나타냅니다. 결과 배열에서 빈 부분 문자열을 생략하려면 Split(Char[], StringSplitOptions) 오버로드를 호출하고 options 매개 변수의 StringSplitOptions.RemoveEmptyEntries을 지정합니다.

string s = "You win some. You lose some.";
char[] separators = new char[] { ' ', '.' };

string[] subs = s.Split(separators, StringSplitOptions.RemoveEmptyEntries);

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring: You
// Substring: lose
// Substring: some

의 개별 오버 로드에 대 한 섹션에는 String.Split() 추가 예가 포함 되어 있습니다.

Split(Char, Int32, StringSplitOptions)

지정된 구분 문자 및 옵션(필요에 따라)에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다. 제공된 문자 구분 기호에 따라 문자열을 최대 개수의 부분 문자열로 분할하고 필요에 따라 결과에서 빈 부분 문자열을 생략합니다.

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

이 인스턴스에서 부분 문자열을 구분하는 문자입니다.

count
Int32

배열에 필요한 최대 요소 수입니다.

options
StringSplitOptions

부분 문자열을 자르고 빈 부분 문자열을 포함할지를 지정하는 열거형 값의 비트 조합입니다.

반환

String[]

separator로 구분되는 이 인스턴스의 부분 문자열이 최대 count개 포함된 배열입니다.

설명

문자열이 이미 count 1번 분할되었지만 문자열의 끝에 도달하지 않은 경우 반환된 배열의 마지막 문자열에 이 인스턴스의 남은 후행 부분 문자열이 그대로 포함됩니다.

적용 대상

Split(String[], Int32, StringSplitOptions)

지정된 구분 문자열 및 옵션(필요에 따라)에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다.

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

매개 변수

separator
String[]

이 문자열의 부분 문자열을 구분하는 문자열, 구분 기호를 포함하지 않는 빈 배열 또는 null입니다.

count
Int32

반환할 부분 문자열의 최대 수입니다.

options
StringSplitOptions

부분 문자열을 자르고 빈 부분 문자열을 포함할지를 지정하는 열거형 값의 비트 조합입니다.

반환

String[]

해당 요소에 separator에 있는 하나 이상의 문자열로 구분되는 이 문자열의 부분 문자열이 포함된 배열입니다. 자세한 내용은 설명 섹션을 참조하세요.

특성

예외

count가 음수입니다.

optionsStringSplitOptions 값 중 하나가 아닙니다.

예제

다음 예제에서는 열거형을 사용 하 여 StringSplitOptions 메서드에서 생성 된 부분 문자열을 포함 하거나 제외 합니다 Split .

// 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.Split() 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 \"{s1}\".");
Console.WriteLine($"The delimiter character is '{charSeparators[0]}'.\n");

// 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 \"{s2}\".");
Console.WriteLine($"The delimiter string is \"{stringSeparators[0]}\".\n");

// 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 {entries.Length} elements:");
    foreach (string entry in entries)
    {
        Console.Write($"<{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]>

*/

설명

구분 기호 문자열은 반환 된 배열의 요소에 포함 되지 않습니다.

이 인스턴스에에 문자열이 포함 되어 있지 separator 않거나 count 매개 변수가 1 이면 반환 된 배열은이 인스턴스가 포함 된 단일 요소로 구성 됩니다.

separator매개 변수가 null 이거나 문자를 포함 하지 않는 경우 공백 문자는 구분 기호로 간주 됩니다. 공백 문자는 유니코드 표준에 의해 정의 되며 Char.IsWhiteSpace 메서드에서 true 전달 되는 경우 반환 됩니다.

매개 변수를 전달 하려면 null string[] separator 의 형식을 지정 null 하 여와 같은 다른 오버 로드에서 호출을 명확 하 게 지정 해야 합니다 Split(Char[], Int32, StringSplitOptions) . 다음 예제에서는이 오버 로드를 명확 하 게 식별 하는 여러 가지 방법을 보여 줍니다.

string phrase = "The quick  brown fox";

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

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

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

count매개 변수가 0 이거나 options 매개 변수가이 RemoveEmptyEntries 고이 인스턴스의 길이가 0 이면 빈 배열이 반환 됩니다.

의 각 요소는 separator 하나 이상의 문자로 구성 된 별도의 구분 기호를 정의 합니다. options매개 변수가이 None 고, 두 구분 기호가 인접 하거나,이 인스턴스의 시작 부분 또는 끝 부분에 구분 기호가 있는 경우 해당 배열 요소는를 포함 합니다 Empty .

count이 인스턴스에 부분 문자열이 있는 경우 첫 번째 count 빼기 1 부분 문자열이 count 반환 값의 첫 번째 빼기 1 요소에 반환 되 고이 인스턴스의 나머지 문자는 반환 값의 마지막 요소에서 반환 됩니다.

count가 부분 문자열의 수보다 크면 사용 가능한 부분 문자열이 반환 되 고 예외가 throw 되지 않습니다.

구분 기호 배열입니다.

의 요소가 separator 여러 문자로 구성 된 경우 전체 부분 문자열이 구분 기호로 간주 됩니다. 예를 들어의 요소 중 하나가 separator "10" 인 경우 "This10is10a10string" 문자열을 분할 하려고 시도 합니다. 이 4 개 요소 배열을 반환 합니다. {"This", "is", "a", "string" }.

비교 정보

Split메서드는 매개 변수에서 하나 이상의 문자열로 구분 되는이 문자열의 부분 문자열을 추출 separator 하 고 해당 부분 문자열을 배열의 요소로 반환 합니다.

Split메서드는 대/소문자 구분 서 수 정렬 규칙을 사용 하 여 비교를 수행 하 여 구분 기호를 찾습니다. 단어, 문자열 및 서 수 정렬에 대 한 자세한 내용은 열거형을 참조 하세요 System.Globalization.CompareOptions .

Split메서드는 separator 값이 null 이거나 빈 문자열 ("") 인의 요소를 무시 합니다.

의 문자열에 공통 된 문자가 있는 경우 모호한 결과를 방지 하기 위해 separator Split 메서드는 인스턴스 값의 처음부터 끝까지 진행 되 고 separator 인스턴스의 구분 기호와 같은의 첫 번째 요소와 일치 합니다. 인스턴스에서 부분 문자열이 발생 하는 순서는의 요소 순서 보다 우선적으로 적용 됩니다 separator .

예를 들어 값이 "abcdef" 인 인스턴스를 생각해 보겠습니다. 의 첫 번째 요소가 separator "ef"이 고 두 번째 요소가 "bcde" 인 경우 split 작업의 결과는 "a" 및 "f"입니다. 이는 "bcde" 인스턴스의 부분 문자열이 발생 하 고 separator 부분 문자열 "f"가 발생 하기 전에의 요소와 일치 하기 때문입니다.

그러나의 첫 번째 요소가 separator "bcd"이 고 두 번째 요소가 "bc" 인 경우 분할 작업의 결과는 "a" 및 "ef"가 됩니다. 이는 "bcd"가 separator 인스턴스의 구분 기호와 일치 하는의 첫 번째 구분 기호 이기 때문입니다. 구분 기호의 순서가 반대로 바뀌어 첫 번째 요소가 "bc"이 고 두 번째 요소가 "bcd" 였으 면 결과는 "a"와 "def"가 됩니다.

성능 고려 사항

Split메서드는 반환 된 배열 개체에 대해 메모리를 할당 하 고 String 각 배열 요소에 대해 개체를 할당 합니다. 애플리케이션에 필요한 최적의 성능, 메모리 할당을 관리 하는 것이 중요 애플리케이션 사용을 고려 합니다 IndexOf 또는 IndexOfAny 메서드 및 필요에 따라는 Compare 문자열 내에서 부분 문자열을 찾을 방법입니다.

구분 문자에서 문자열을 분할 하는 경우 또는 메서드를 사용 IndexOf IndexOfAny 하 여 문자열에서 구분 기호 문자를 찾습니다. 구분 기호 문자열에서 문자열을 분할 하는 경우 IndexOf 또는 메서드를 사용 IndexOfAny 하 여 구분 기호 문자열의 첫 번째 문자를 찾습니다. 그런 다음 메서드를 사용 Compare 하 여 첫 번째 문자 뒤의 문자가 구분 기호 문자열의 나머지 문자와 같은지 여부를 확인 합니다.

또한 여러 메서드 호출에서 문자열을 분할 하는 데 동일한 문자 집합을 사용 하는 경우 Split 단일 배열을 만들고 각 메서드 호출에서 참조 하는 것이 좋습니다. 이렇게 하면 각 메서드 호출의 추가 오버 헤드가 크게 줄어듭니다.

호출자 참고

.NET Framework 3.5 이전 버전에서 Split(Char[]) 메서드가 또는 문자를 포함 하지 않는를 전달 하는 경우 메서드 separator null 는 약간 다른 공백 문자 집합을 사용 하 여 문자열을 트리밍 하는 방법 보다 문자열을 분할 합니다 Trim(Char[]) . .NET Framework 4부터 두 방법 모두 동일한 유니코드 공백 문자 집합을 사용 합니다.

적용 대상

Split(Char[], Int32, StringSplitOptions)

지정된 구분 문자 및 옵션(필요에 따라)에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다.

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

매개 변수

separator
Char[]

이 문자열의 부분 문자열을 구분하는 문자 배열, 구분 기호를 포함하지 않는 빈 배열 또는 null입니다.

count
Int32

반환할 부분 문자열의 최대 수입니다.

options
StringSplitOptions

부분 문자열을 자르고 빈 부분 문자열을 포함할지를 지정하는 열거형 값의 비트 조합입니다.

반환

String[]

separator에 있는 하나 이상의 문자로 구분되는 이 문자열의 부분 문자열이 포함된 배열입니다. 자세한 내용은 설명 섹션을 참조하세요.

특성

예외

count가 음수입니다.

optionsStringSplitOptions 값 중 하나가 아닙니다.

예제

다음 예제에서는 열거형을 사용 하 여 StringSplitOptions 메서드에서 생성 된 부분 문자열을 포함 하거나 제외 합니다 Split .

// 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.Split() 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 \"{s1}\".");
Console.WriteLine($"The delimiter character is '{charSeparators[0]}'.\n");

// 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 \"{s2}\".");
Console.WriteLine($"The delimiter string is \"{stringSeparators[0]}\".\n");

// 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 {entries.Length} elements:");
    foreach (string entry in entries)
    {
        Console.Write($"<{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]>

*/

설명

구분 기호 문자는 반환된 배열의 요소에 포함되지 않습니다.

이 인스턴스에 의 문자가 없거나 separator 매개 count 변수가 1이면 반환된 배열은 이 인스턴스를 포함하는 단일 요소로 구성됩니다.

매개 separator 변수가 null 이거나 문자가 없는 경우 공백 문자는 구분 기호로 간주합니다. 공백 문자는 유니코드 표준에 의해 정의되고 Char.IsWhiteSpace 메서드는 전달되면 를 true 반환합니다.

매개 변수에 대해 를 전달하려면 null char[] separator 의 형식을 null 지정하여 과 같은 일부 다른 오버로드에서 호출을 명확하게 해야 Split(String[], Int32, StringSplitOptions) 합니다. 다음 예제에서는 이 오버로드를 명확하게 식별하는 여러 가지 방법을 보여 있습니다.

string phrase = "The quick  brown fox";

_ = phrase.Split(default(char[]), 3, StringSplitOptions.RemoveEmptyEntries);

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

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

매개 count 변수가 0이거나 options 매개 변수가 RemoveEmptyEntries 이고 이 인스턴스의 길이가 0이면 빈 배열이 반환됩니다.

의 각 요소는 separator 별도의 구분 기호 문자를 정의합니다. 매개 options 변수가 None 이고 두 구분 기호가 인접하거나 이 인스턴스의 시작 또는 끝에 구분 기호가 있으면 해당 배열 요소에 가 포함됩니다. Empty

count이 인스턴스에 부분 문자열이 있는 경우 첫 번째 count 빼기 1 부분 문자열이 count 반환 값의 첫 번째 빼기 1 요소에 반환 되 고이 인스턴스의 나머지 문자는 반환 값의 마지막 요소에서 반환 됩니다.

count가 부분 문자열의 수보다 크면 사용 가능한 부분 문자열이 반환 되 고 예외가 throw 되지 않습니다.

성능 고려 사항

Split메서드는 반환 된 배열 개체에 대해 메모리를 할당 하 고 String 각 배열 요소에 대해 개체를 할당 합니다. 애플리케이션에 필요한 최적의 성능, 메모리 할당을 관리 하는 것이 중요 애플리케이션 사용을 고려 합니다 IndexOf 또는 IndexOfAny 메서드 및 필요에 따라는 Compare 문자열 내에서 부분 문자열을 찾을 방법입니다.

구분 문자에서 문자열을 분할 하는 경우 또는 메서드를 사용 IndexOf IndexOfAny 하 여 문자열에서 구분 기호 문자를 찾습니다. 구분 기호 문자열에서 문자열을 분할 하는 경우 IndexOf 또는 메서드를 사용 IndexOfAny 하 여 구분 기호 문자열의 첫 번째 문자를 찾습니다. 그런 다음 메서드를 사용 Compare 하 여 첫 번째 문자 뒤의 문자가 구분 기호 문자열의 나머지 문자와 같은지 여부를 확인 합니다.

또한 여러 메서드 호출에서 문자열을 분할 하는 데 동일한 문자 집합을 사용 하는 경우 Split 단일 배열을 만들고 각 메서드 호출에서 참조 하는 것이 좋습니다. 이렇게 하면 각 메서드 호출의 추가 오버 헤드가 크게 줄어듭니다.

호출자 참고

.NET Framework 3.5 이전 버전에서 Split(Char[]) 메서드가 또는 문자를 포함 하지 않는를 전달 하는 경우 메서드 separator null 는 약간 다른 공백 문자 집합을 사용 하 여 문자열을 트리밍 하는 방법 보다 문자열을 분할 합니다 Trim(Char[]) . .NET Framework 4부터 두 방법 모두 동일한 유니코드 공백 문자 집합을 사용 합니다.

적용 대상

Split(String[], StringSplitOptions)

지정된 구분 문자열 및 옵션(필요에 따라)에 따라 문자열을 부분 문자열로 분할합니다.

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

매개 변수

separator
String[]

이 문자열의 부분 문자열을 구분하는 문자열 배열, 구분 기호를 포함하지 않는 빈 배열 또는 null입니다.

options
StringSplitOptions

부분 문자열을 자르고 빈 부분 문자열을 포함할지를 지정하는 열거형 값의 비트 조합입니다.

반환

String[]

해당 요소에 separator에 있는 하나 이상의 문자열로 구분되는 이 문자열의 부분 문자열이 포함된 배열입니다. 자세한 내용은 설명 섹션을 참조하세요.

특성

예외

optionsStringSplitOptions 값 중 하나가 아닙니다.

예제

다음 예제에서는 및 와 같은 매개 변수를 사용하여 문자열의 메서드를 호출하여 반환되는 배열의 차이를 보여 String.Split(String[], StringSplitOptions) options StringSplitOptions.None 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   \"{source}\".");
Console.WriteLine();
Console.WriteLine($"Using the delimiter string:\n   \"{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 ({result.Length} elements):");
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 ({result.Length} elements):");
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'

다음 예제에서는 문장 부호 및 공백 문자를 포함하는 구분 기호 배열을 정의합니다. 값과 함께 이 배열을 메서드에 전달하면 StringSplitOptions.RemoveEmptyEntries Split(String[], StringSplitOptions) 문자열의 개별 단어로 구성된 배열이 반환됩니다.

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

인수를 로 설정하여 메서드를 options StringSplitOptions.RemoveEmptyEntries 호출합니다. 이렇게 하면 반환된 배열에 String.Empty 문장 부호와 공백 문자 간의 빈 부분 문자 일치를 나타내는 값이 포함되지 않습니다.

설명

문자열이 알려진 문자열 집합으로 구분된 경우 메서드를 사용하여 Split 부분 문자열로 구분할 수 있습니다.

구분 기호 문자열은 반환된 배열의 요소에 포함되지 않습니다. 예를 들어 separator 배열에 문자열 "--"이 포함되고 현재 문자열 인스턴스의 값이 "aa--bb--cc"인 경우 메서드는 "aa", "bb" 및 "cc"라는 세 개의 요소가 포함된 배열을 반환합니다.

이 인스턴스에 의 문자열이 없으면 separator 반환된 배열은 이 인스턴스를 포함하는 단일 요소로 구성됩니다.

매개 options 변수가 RemoveEmptyEntries 이고 이 인스턴스의 길이가 0이면 메서드는 빈 배열을 반환합니다.

의 각 요소는 separator 하나 이상의 문자로 구성된 별도의 구분 기호를 정의합니다. options인수가 None 이고 두 구분 기호가 인접하거나 이 인스턴스의 시작 또는 끝에 구분 기호가 있으면 해당 배열 요소에 가 포함됩니다. String.Empty 예를 들어 에 separator "-" 및 " "라는 두 요소가 포함된 경우 _ 문자열 인스턴스의 값은 "- _ aa- _ "이고 options 인수의 값은 None 입니다. 메서드는 다음 5개의 요소가 포함된 문자열 배열을 반환합니다.

  1. String.Empty- 인덱스 0에서 "-" 부분 문자열 앞에 오는 빈 문자열을 나타냅니다.

  2. String.Empty- 인덱스 0의 "-" 부분 문자열과 인덱스 1의 "_" 부분 문자열 사이의 빈 문자열을 나타냅니다.

  3. "aa".

  4. String.Empty- 인덱스 4에서 "-" 부분 문자열 뒤에 있는 빈 문자열을 나타냅니다.

  5. String.Empty- 인덱스 5의 "_" 부분 문자열 뒤에 있는 빈 문자열을 나타냅니다.

구분 기호 배열

의 요소가 여러 separator 문자로 구성된 경우 전체 부분 부분은 구분 기호로 간주됩니다. 예를 들어 의 요소 중 하나가 separator "10"이면 문자열 "This10is10a10string"을 분할하려고 합니다. 다음 네 요소 배열을 반환합니다. { "This", "is", "a", "string." }.

매개 separator 변수가 null 이거나 비어 있지 않은 문자열을 포함하지 않는 경우 공백 문자는 구분 기호로 간주합니다. 공백 문자는 유니코드 표준에 의해 정의되고 Char.IsWhiteSpace 메서드는 전달되면 를 true 반환합니다.

매개 변수에 대해 를 전달하려면 null string[] separator 의 형식을 null 지정하여 과 같은 일부 다른 오버로드에서 호출을 명확하게 해야 Split(Char[], StringSplitOptions) 합니다. 다음 예제에서는 이 오버로드를 명확하게 식별하는 여러 가지 방법을 보여 있습니다.

string phrase = "The quick  brown fox";

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

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

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

비교 세부 정보

Split메서드는 매개 변수에 있는 하나 이상의 문자열로 구분된 이 문자열의 부분 문자열을 separator 추출하고 해당 부분 문자열을 배열의 요소로 반환합니다.

Split메서드는 대/소문자를 구분하는 서수 정렬 규칙을 사용하여 비교를 수행하여 구분 기호를 찾습니다. 단어, 문자열 및 서수 정렬에 대한 자세한 내용은 System.Globalization.CompareOptions 열거형을 참조하세요.

Split메서드는 separator 값이 또는 빈 null 문자열("")인 의 요소를 무시합니다.

의 문자열에 공통된 문자가 있는 경우 모호한 결과를 방지하기 위해 separator Split 작업은 인스턴스 값의 처음부터 끝까지 진행되며 인스턴스의 구분 기호와 같은 의 첫 번째 요소와 separator 일치합니다. 인스턴스에서 부분string이 발생하는 순서가 의 요소 순서보다 separator 우선합니다.

예를 들어 값이 "abcdef"인 인스턴스를 생각해 보겠습니다. 의 첫 번째 요소가 separator "ef"이고 두 번째 요소가 "bcde"인 경우 분할 작업의 결과는 "a" 및 "f"라는 두 개의 요소를 포함하는 문자열 배열이 됩니다. 이는 인스턴스 "bcde"의 부분string이 발생하여 separator 부분스트링 "f"가 발생하기 전에 의 요소와 일치하기 때문입니다.

그러나 의 첫 번째 요소가 separator "bcd"이고 두 번째 요소가 "bc"인 경우 분할 작업의 결과는 "a" 및 "ef"라는 두 개의 요소를 포함하는 문자열 배열이 됩니다. 이는 "bcd"가 인스턴스의 구분 기호와 일치하는 의 첫 번째 separator 구분 기호이기 때문입니다. 첫 번째 요소가 "bc"이고 두 번째 요소가 "bcd"가 되도록 구분 기호의 순서가 반대로 바뀐 경우 결과는 두 개의 요소 "a"와 "def"를 포함하는 문자열 배열이 됩니다.

성능 고려 사항

Split메서드는 반환된 배열 개체에 메모리를 할당하고 String 각 배열 요소에 대해 개체를 할당합니다. 애플리케이션에 필요한 최적의 성능, 메모리 할당을 관리 하는 것이 중요 애플리케이션 사용을 고려 합니다 IndexOf 또는 IndexOfAny 메서드 및 필요에 따라는 Compare 문자열 내에서 부분 문자열을 찾을 방법입니다.

구분 문자에서 문자열을 분할하는 경우 또는 IndexOf 메서드를 사용하여 IndexOfAny 문자열에서 구분 기호 문자를 찾습니다. 구분 기호 문자열에서 문자열을 분할하는 경우 또는 메서드를 사용하여 구분 기호 IndexOf IndexOfAny 문자열의 첫 번째 문자를 찾습니다. 그런 다음 메서드를 사용하여 Compare 첫 번째 문자 뒤의 문자가 구분 기호 문자열의 나머지 문자와 같은지 여부를 확인합니다.

또한 동일한 문자 집합을 사용하여 여러 메서드 호출에서 문자열을 분할하는 경우 Split 단일 배열을 만들고 각 메서드 호출에서 참조하는 것이 좋습니다. 이렇게 하면 각 메서드 호출의 추가 오버헤드가 크게 줄어듭니다.

호출자 참고

.NET Framework 3.5 및 이전 버전에서 Split(Char[]) 메서드가 전달되는 경우 separator 문자가 없거나 null 문자가 없는 메서드는 약간 다른 공백 문자 집합을 사용하여 문자열을 Trim(Char[]) 분할합니다. .NET Framework 4부터 두 메서드는 동일한 유니코드 공백 문자 집합을 사용합니다.

적용 대상

Split(String, Int32, StringSplitOptions)

지정된 구분 문자열 및 옵션(필요에 따라)에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다.

public string[] Split (string? separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
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

이 인스턴스에서 부분 문자열을 구분하는 문자열입니다.

count
Int32

배열에 필요한 최대 요소 수입니다.

options
StringSplitOptions

부분 문자열을 자르고 빈 부분 문자열을 포함할지를 지정하는 열거형 값의 비트 조합입니다.

반환

String[]

separator로 구분되는 이 인스턴스의 부분 문자열이 최대 count개 포함된 배열입니다.

설명

문자열이 이미 분할 된 경우 count 문자열의 끝에 도달 하지 않은 경우 반환 된 배열의 마지막 문자열에는이 인스턴스의 나머지 후행 부분 문자열이 그대로 포함 됩니다.

적용 대상

Split(Char[], StringSplitOptions)

지정된 구분 문자 및 옵션에 따라 문자열을 부분 문자열로 분할합니다.

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

매개 변수

separator
Char[]

이 문자열의 부분 문자열을 구분하는 문자 배열, 구분 기호를 포함하지 않는 빈 배열 또는 null입니다.

options
StringSplitOptions

부분 문자열을 자르고 빈 부분 문자열을 포함할지를 지정하는 열거형 값의 비트 조합입니다.

반환

String[]

해당 요소에 separator에 있는 하나 이상의 문자로 구분되는 이 문자열의 부분 문자열이 포함된 배열입니다. 자세한 내용은 설명 섹션을 참조하세요.

특성

예외

optionsStringSplitOptions 값 중 하나가 아닙니다.

예제

다음 예제에서는 StringSplitOptions 열거형을 사용 하 여 포함 하거나에서 생성 된 부분string을 제외 하는 Split 메서드.

// 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.Split() 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 \"{s1}\".");
Console.WriteLine($"The delimiter character is '{charSeparators[0]}'.\n");

// 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 \"{s2}\".");
Console.WriteLine($"The delimiter string is \"{stringSeparators[0]}\".\n");

// 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 {entries.Length} elements:");
    foreach (string entry in entries)
    {
        Console.Write($"<{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]>

*/

설명

구분 기호 문자 ( separator 배열의 문자)는 반환 된 배열의 요소에 포함 되지 않습니다. 예를 들어 배열에 separator "-" 문자가 포함 되 고 현재 문자열 인스턴스의 값이 "aa-bb-cc" 인 경우이 메서드는 "aa", "bb" 및 "cc"의 세 요소가 포함 된 배열을 반환 합니다.

이 인스턴스에에 문자가 포함 되어 있지 않으면 separator 반환 된 배열은이 인스턴스가 포함 된 단일 요소로 구성 됩니다.

options매개 변수가이 RemoveEmptyEntries 고이 인스턴스의 길이가 0 인 경우이 메서드는 빈 배열을 반환 합니다.

의 각 요소는 separator 단일 문자로 구성 된 별도의 구분 기호를 정의 합니다. 인수가이 options None 고 두 구분 기호가 인접 하거나이 인스턴스의 시작 부분 또는 끝 부분에 구분 기호가 있는 경우 해당 배열 요소는를 포함 String.Empty 합니다. 예를 들어, separator 및에 두 개의 요소가 포함 된 경우 '-' '_' 문자열 인스턴스의 값은 "- _ aa- _ "이 고 인수의 값은 options 입니다 None .이 메서드는 다음과 같은 5 개의 요소를 포함 하는 문자열 배열을 반환 합니다.

  1. String.Empty인덱스 0에서 "-" 문자 앞에 오는 빈 문자열을 나타내는입니다.

  2. String.Empty-인덱스 0의 "-" 문자와 인덱스 1의 "_" 문자 사이에 있는 빈 문자열을 나타냅니다.

  3. "aa".

  4. String.Empty-인덱스 4에서 "-" 문자 뒤에 오는 빈 문자열을 나타냅니다.

  5. String.Empty인덱스 5에서 "_" 문자 뒤에 오는 빈 문자열을 나타내는입니다.

구분 기호 배열입니다.

separator매개 변수가 null 이거나 문자를 포함 하지 않는 경우 공백 문자는 구분 기호로 간주 됩니다. 공백 문자는 유니코드 표준에 의해 정의되고 Char.IsWhiteSpace 메서드는 전달되면 를 true 반환합니다.

매개 변수에 대해 를 전달하려면 null char[] separator 의 형식을 null 지정하여 과 같은 일부 다른 오버로드에서 호출을 명확하게 해야 Split(String[], StringSplitOptions) 합니다. 다음 예제에서는 이 오버로드를 명확하게 식별하는 여러 가지 방법을 보여 있습니다.

string phrase = "The quick  brown fox";

_ = phrase.Split(default(char[]), StringSplitOptions.RemoveEmptyEntries);

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

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

비교 세부 정보

Split메서드는 매개 변수에 있는 하나 이상의 문자로 구분된 이 문자열의 부분 문자열을 separator 추출하고 해당 부분 문자열을 배열의 요소로 반환합니다.

Split메서드는 대/소문자를 구분하는 서수 정렬 규칙을 사용하여 비교를 수행하여 구분 기호를 찾습니다. 단어, 문자열 및 서수 정렬에 대한 자세한 내용은 System.Globalization.CompareOptions 열거형을 참조하세요.

성능 고려 사항

Split메서드는 반환된 배열 개체에 메모리를 할당하고 String 각 배열 요소에 대해 개체를 할당합니다. 애플리케이션에 필요한 최적의 성능, 메모리 할당을 관리 하는 것이 중요 애플리케이션 사용을 고려 합니다 IndexOf 또는 IndexOfAny 메서드 및 필요에 따라는 Compare 문자열 내에서 부분 문자열을 찾을 방법입니다.

구분 문자에서 문자열을 분할하는 경우 또는 IndexOf 메서드를 사용하여 IndexOfAny 문자열에서 구분 기호 문자를 찾습니다. 구분 기호 문자열에서 문자열을 분할하는 경우 또는 메서드를 사용하여 구분 기호 IndexOf IndexOfAny 문자열의 첫 번째 문자를 찾습니다. 그런 다음 메서드를 사용하여 Compare 첫 번째 문자 뒤의 문자가 구분 기호 문자열의 나머지 문자와 같은지 여부를 확인합니다.

또한 동일한 문자 집합을 사용하여 여러 메서드 호출에서 문자열을 분할하는 경우 Split 단일 배열을 만들고 각 메서드 호출에서 참조하는 것이 좋습니다. 이렇게 하면 각 메서드 호출의 추가 오버헤드가 크게 줄어듭니다.

호출자 참고

.NET Framework 3.5 및 이전 버전에서 Split(Char[]) 메서드가 전달되는 경우 separator 문자가 없거나 null 문자가 없는 메서드는 약간 다른 공백 문자 집합을 사용하여 문자열을 Trim(Char[]) 분할합니다. .NET Framework 4부터 두 메서드는 동일한 유니코드 공백 문자 집합을 사용합니다.

적용 대상

Split(Char[], Int32)

지정된 구분 문자에 따라 문자열을 최대 개수의 부분 문자열로 분할합니다.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count);
public string[] Split (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입니다.

count
Int32

반환할 부분 문자열의 최대 수입니다.

반환

String[]

해당 요소에 separator에 있는 하나 이상의 문자로 구분되는 이 인스턴스의 부분 문자열이 포함된 배열입니다. 자세한 내용은 설명 섹션을 참조하세요.

예외

count가 음수입니다.

예제

다음 예에서는를 count 사용 하 여에서 반환 되는 문자열 수를 제한 하는 방법을 보여 줍니다 Split .

string name = "Alex Johnson III";

string[] subs = name.Split(null, 2);

string firstName = subs[0];
string lastName;
if (subs.Length > 1)
{
    lastName = subs[1];
}

// firstName = "Alex"
// lastName = "Johnson III"

설명

구분 기호 문자는 반환 된 배열의 요소에 포함 되지 않습니다.

이 인스턴스에에 문자가 포함 되어 있지 않으면 separator 반환 된 배열은이 인스턴스가 포함 된 단일 요소로 구성 됩니다. count가 0 이면 빈 배열이 반환 됩니다.

separator매개 변수가 null 이거나 문자를 포함 하지 않는 경우 공백 문자는 구분 기호로 간주 됩니다. 공백 문자는 유니코드 표준에 의해 정의 되며 Char.IsWhiteSpace 메서드에서 true 전달 되는 경우 반환 됩니다.

의 각 요소 separator 는 별도의 구분 기호 문자를 정의 합니다. 두 구분 기호가 인접 하거나이 인스턴스의 시작 부분 또는 끝 부분에 구분 기호가 있으면 해당 하는 배열 요소는를 포함 Empty 합니다.

count이 인스턴스에 부분 문자열이 있는 경우 첫 번째 count - 1 부분 문자열은 반환 값의 첫 번째 요소에서 반환 되 count - 1 고이 인스턴스의 나머지 문자는 반환 값의 마지막 요소에서 반환 됩니다.

count가 부분 문자열의 수보다 크면 사용 가능한 부분 문자열이 반환 되 고 예외가 throw 되지 않습니다.

다음 표에서 몇 가지 예를 보여 줍니다.

언어 문자열 값 구분 기호 반환 된 배열
C# "42, 12, 19" new Char [] {', ', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char () = {"," c "," c}) {"42", "", "12", "", "19"}
C# "42 ... 12 ...." 새 Char [] {'. '} {"42", "", "12", "", "19", ""}
Visual Basic "42 ... 12 ...." Char () = {"." c {"42", "", "12", "", "19", ""}
C# 바나나 새 Char [] {'. '} {"바나나"}
Visual Basic 바나나 Char () = {"." c {"바나나"}
C# "Darb\nSmarba" new Char [] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char () = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" null {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nothing {"Darb", "Smarba"}

성능 고려 사항

Split메서드는 반환 된 배열 개체에 대해 메모리를 할당 하 고 String 각 배열 요소에 대해 개체를 할당 합니다. 애플리케이션에 필요한 최적의 성능, 메모리 할당을 관리 하는 것이 중요 애플리케이션 사용을 고려 합니다 IndexOf 또는 IndexOfAny 메서드 및 필요에 따라는 Compare 문자열 내에서 부분 문자열을 찾을 방법입니다.

구분 문자에서 문자열을 분할 하는 경우 또는 메서드를 사용 IndexOf IndexOfAny 하 여 문자열에서 구분 기호 문자를 찾습니다. 구분 기호 문자열에서 문자열을 분할 하는 경우 IndexOf 또는 메서드를 사용 IndexOfAny 하 여 구분 기호 문자열의 첫 번째 문자를 찾습니다. 그런 다음 메서드를 사용 Compare 하 여 첫 번째 문자 뒤의 문자가 구분 기호 문자열의 나머지 문자와 같은지 여부를 확인 합니다.

또한 여러 메서드 호출에서 문자열을 분할 하는 데 동일한 문자 집합을 사용 하는 경우 Split 단일 배열을 만들고 각 메서드 호출에서 참조 하는 것이 좋습니다. 이렇게 하면 각 메서드 호출의 추가 오버 헤드가 크게 줄어듭니다.

호출자 참고

.NET Framework 3.5 이전 버전에서 Split(Char[]) 메서드가 또는 문자를 포함 하지 않는를 전달 하는 경우 메서드 separator null 는 약간 다른 공백 문자 집합을 사용 하 여 문자열을 트리밍 하는 방법 보다 문자열을 분할 합니다 Trim(Char[]) . .NET Framework 4부터 두 방법 모두 동일한 유니코드 공백 문자 집합을 사용 합니다.

추가 정보

적용 대상

Split(Char, StringSplitOptions)

지정된 구분 문자 및 옵션(필요에 따라)에 따라 문자열을 부분 문자열로 분할합니다.

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

이 문자열에서 부분 문자열을 구분하는 문자입니다.

options
StringSplitOptions

부분 문자열을 자르고 빈 부분 문자열을 포함할지를 지정하는 열거형 값의 비트 조합입니다.

반환

String[]

요소에 separator로 구분되는 이 인스턴스의 부분 문자열이 포함된 배열입니다.

적용 대상

Split(String, StringSplitOptions)

문자열을 제공된 문자열 구분 기호에 기초하는 부분 문자열로 분할합니다.

public string[] Split (string? separator, StringSplitOptions options = System.StringSplitOptions.None);
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

이 문자열에서 부분 문자열을 구분하는 문자열입니다.

options
StringSplitOptions

부분 문자열을 자르고 빈 부분 문자열을 포함할지를 지정하는 열거형 값의 비트 조합입니다.

반환

String[]

요소에 separator로 구분되는 이 인스턴스의 부분 문자열이 포함된 배열입니다.

적용 대상

Split(Char[])

지정된 구분 문자에 따라 문자열을 부분 문자열로 분할합니다.

public:
 cli::array <System::String ^> ^ Split(... cli::array <char> ^ separator);
public string[] Split (params 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입니다.

반환

String[]

요소에 separator에 있는 하나 이상의 문자로 구분되는 이 인스턴스의 부분 문자열이 포함된 배열입니다. 자세한 내용은 설명 섹션을 참조하세요.

예제

다음 예제에서는 공백 문자 ( )와 탭 문자 ()를 구분 기호로 처리 하 여 텍스트 블록에서 개별 단어를 추출 하는 방법을 보여 줍니다 \t . 분할 되는 문자열에는 이러한 문자가 모두 포함 됩니다.

string s = "Today\tI'm going to school";
string[] subs = s.Split(' ', '\t');

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: Today
// Substring: I'm
// Substring: going
// Substring: to
// Substring: school

설명

문자열이 알려진 문자 집합으로 구분 되는 경우 메서드를 사용 하 여 해당 문자열을 부분 문자열로 구분할 수 있습니다 Split(Char[]) .

구분 기호 문자는 반환 된 배열의 요소에 포함 되지 않습니다. 예를 들어, 구분 기호 배열에 "-" 문자가 포함 되 고 현재 문자열 인스턴스의 값이 "aa-bb-cc" 인 경우이 메서드는 "aa", "bb" 및 "cc" 라는 세 개의 요소가 포함 된 배열을 반환 합니다.

이 인스턴스에에 문자가 포함 되어 있지 않으면 separator 반환 된 배열은이 인스턴스가 포함 된 단일 요소로 구성 됩니다.

의 각 요소 separator 는 별도의 구분 기호 문자를 정의 합니다. 두 구분 기호가 인접 하거나이 인스턴스의 시작 부분 또는 끝 부분에 구분 기호가 있으면 반환 된 배열의 해당 요소에가 포함 됩니다 Empty .

다음 표에서 몇 가지 예를 보여 줍니다.

언어 문자열 값 구분 기호 반환 된 배열
C# "42, 12, 19" new Char [] {', ', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char () = {"," c "," c}) {"42", "", "12", "", "19"}
C# "42 ... 12 ...." 새 Char [] {'. '} {"42", "", "12", "", "19", ""}
Visual Basic "42 ... 12 ...." Char () = {"." c {"42", "", "12", "", "19", ""}
C# 바나나 새 Char [] {'. '} {"바나나"}
Visual Basic 바나나 Char () = {"." c {"바나나"}
C# "Darb\nSmarba" new Char [] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char () = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" null {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nothing {"Darb", "Smarba"}

구분 기호 배열입니다.

구분 기호의 각 요소는 단일 문자로 구성 된 별도의 구분 기호를 정의 합니다.

separator인수가 null 이거나 문자를 포함 하지 않는 경우 메서드는 공백 문자를 구분 기호로 처리 합니다. 공백 문자는 유니코드 표준에 의해 정의 되며, 메서드는 공백 Char.IsWhiteSpace 문자를 true 전달 하는 경우를 반환 합니다.

String.format (Char []) 및 컴파일러 오버 로드 확인

의이 오버 로드에 대 한 단일 매개 변수는 String.Split 문자 배열 이지만 다음 예제에 나와 있는 것 처럼 단일 문자를 사용 하 여 호출할 수 있습니다.

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.

separator매개 변수는 특성으로 데코 레이트 되므로 ParamArrayAttribute 컴파일러는 단일 문자를 단일 요소 문자 배열로 해석 합니다. 이는 String.Split 매개 변수를 포함 하는 다른 오버 로드의 경우에는 그렇지 않습니다. separator 이러한 오버 로드를 문자 배열에 인수로 명시적으로 전달 해야 합니다 separator .

비교 정보

Split(Char[])메서드는 배열에 있는 하나 이상의 문자로 구분 되는이 문자열의 부분 문자열을 추출 separator 하 고 해당 부분 문자열을 배열의 요소로 반환 합니다.

Split(Char[])메서드는 대/소문자 구분 서 수 정렬 규칙을 사용 하 여 비교를 수행 하 여 구분 기호를 찾습니다. 단어, 문자열 및 서 수 정렬에 대 한 자세한 내용은 열거형을 참조 하세요 System.Globalization.CompareOptions .

성능 고려 사항

Split메서드는 반환 된 배열 개체에 대해 메모리를 할당 하 고 String 각 배열 요소에 대해 개체를 할당 합니다. 애플리케이션에 필요한 최적의 성능, 메모리 할당을 관리 하는 것이 중요 애플리케이션 사용을 고려 합니다 IndexOf 또는 IndexOfAny 메서드. 또한 메서드를 사용 하 여 Compare 문자열 내에서 부분 문자열을 찾는 옵션도 있습니다.

구분 문자에서 문자열을 분할 하려면 또는 메서드를 사용 IndexOf IndexOfAny 하 여 문자열에서 구분 기호 문자를 찾습니다. 구분 기호 문자열에서 문자열을 분할 하려면 IndexOf 또는 메서드를 사용 IndexOfAny 하 여 구분 기호 문자열의 첫 번째 문자를 찾습니다. 그런 다음 메서드를 사용 Compare 하 여 첫 번째 문자 뒤의 문자가 구분 기호 문자열의 나머지 문자와 같은지 여부를 확인 합니다.

또한 여러 메서드 호출에서 문자열을 분할 하는 데 동일한 문자 집합을 사용 하는 경우 Split 단일 배열을 만들고 각 메서드 호출에서 참조 하는 것이 좋습니다. 이렇게 하면 각 메서드 호출의 추가 오버 헤드가 크게 줄어듭니다.

호출자 참고

.NET Framework 3.5 이전 버전에서 Split(Char[]) 메서드가 또는 문자를 포함 하지 않는를 전달 하는 경우 메서드 separator null 는 약간 다른 공백 문자 집합을 사용 하 여 문자열을 트리밍 하는 방법 보다 문자열을 분할 합니다 Trim(Char[]) . .NET Framework 4부터 두 방법 모두 동일한 유니코드 공백 문자 집합을 사용 합니다.

추가 정보

적용 대상