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 используется для разбиения строки с разделителями на подстроки. Можно использовать массив символов или строковый массив для указания нуля или нескольких символов или строк с разделителями. Если символы разделителя не указаны, строка разбивается на пробелы.

Перегрузки 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.
let s = "You win some. You lose some."

let subs = s.Split ' '

for sub in subs do
    printfn $"Substring: {sub}"

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some.
// Substring: You
// Substring: lose
// Substring: some.
Dim s As String = "You win some. You lose some."
Dim subs As String() = s.Split()

For Each substring As String In subs
    Console.WriteLine($"Substring: {substring}")
Next

' 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:
let s = "You win some. You lose some."

let subs = s.Split(' ', '.')

for sub in subs do
    printfn $"Substring: {sub}"

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring:
// Substring: You
// Substring: lose
// Substring: some
// Substring:
Dim s As String = "You win some. You lose some."
Dim subs As String() = s.Split(" "c, "."c)

For Each substring As String In subs
    Console.WriteLine($"Substring: {substring}")
Next

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

Точки исчезли из подстрок, однако теперь появились две дополнительные пустые подстроки. Эта пустая подстрока представляет подстроку между словом и последующим за ним периодом. Чтобы исключить из результирующего массива пустые подстроки, вызовите перегрузку Split(Char[], StringSplitOptions) и укажите StringSplitOptions.RemoveEmptyEntries для параметра options.

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
let s = "You win some. You lose some."
let separators = [| ' '; '.' |]

let subs = s.Split(separators, StringSplitOptions.RemoveEmptyEntries)

for sub in subs do
    printfn $"Substring: {sub}"

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring: You
// Substring: lose
// Substring: some
Dim s As String = "You win some. You lose some."
Dim separators As Char() = New Char() {" "c, "."c}
Dim subs As String() = s.Split(separators, StringSplitOptions.RemoveEmptyEntries)

For Each substring As String In subs
    Console.WriteLine($"Substring: {substring}")
Next

' 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[]

Массив, содержащий подстроки из этого экземпляра (не более count), разделенные символом separator.

Комментарии

Если строка уже разделена 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 является отрицательным значением.

options не является одним из значений StringSplitOptions.

Примеры

В следующем примере перечисление 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]>

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
 
// Display the array of separated strings using a local function
let show  (entries: string[]) =
    printfn $"The return value contains these {entries.Length} elements:"
    for entry in entries do
        printf $"<{entry}>"
    printf "\n\n"

let s1 = ",ONE,,TWO,,,THREE,,"
let s2 = "[stop]" +
         "ONE[stop][stop]" +
         "TWO[stop][stop][stop]" +
         "THREE[stop][stop]"
let charSeparators = [| ',' |]
let stringSeparators = [| "[stop]" |]
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
printfn "1) Split a string delimited by characters:\n"

// Display the original string and delimiter characters.
printfn $"1a) The original string is \"{s1}\"."
printfn $"The delimiter character is '{charSeparators[0]}'.\n"

// Split a string delimited by characters and return all elements.
printfn "1b) Split a string delimited by characters and return all elements:"
let result = s1.Split(charSeparators, StringSplitOptions.None)
show result

// Split a string delimited by characters and return all non-empty elements.
printfn "1c) Split a string delimited by characters and return all non-empty elements:"
let 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.
printfn "1d) Split a string delimited by characters and return 2 elements:"
let 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.
printfn "1e) Split a string delimited by characters and return 2 non-empty elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
printfn "2) Split a string delimited by another string:\n"

// Display the original string and delimiter string.
printfn $"2a) The original string is \"{s2}\"."
printfn $"The delimiter string is \"{stringSeparators[0]}\".\n"

// Split a string delimited by another string and return all elements.
printfn "2b) Split a string delimited by another string and return all elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.None)
show result

// Split the original string at the delimiter and return all non-empty elements.
printfn "2c) Split a string delimited by another string and return all non-empty elements:"
let 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.
printfn "2d) Split a string delimited by another string and return 2 elements:"
let 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.
printfn "2e) Split a string delimited by another string and return 2 non-empty elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

(*
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]>

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

'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);
let phrase = "The quick  brown fox"

phrase.Split(Unchecked.defaultof<string[]>, 3, StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split(null :> string[], 3, StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split((null: string[]), 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
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 Если параметр равен нулю или options параметр равен RemoveEmptyEntries нулю, а длина этого экземпляра равна нулю, возвращается пустой массив.

Каждый элемент separator определяет отдельный разделитель, состоящий из одного или нескольких символов. options Если параметр имеет значение None, а два разделителя являются смежными или разделителем находятся в начале или конце этого экземпляра, соответствующий элемент массива содержитEmpty.

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

Если count значение больше числа подстрок, возвращаются доступные подстроки и исключение не возникает.

Массив разделителей

Если любой из элементов состоит separator из нескольких символов, то вся подстрока считается разделителем. Например, если один из элементов имеет separator значение "10", попытка разделить строку "This10is10a10string". возвращает этот массив из четырех элементов: { "This", "is", "a", "string". }.

Сведения о сравнении

Метод Split извлекает подстроки в этой строке, разделенные одной или несколькими строками в параметре separator , и возвращает эти подстроки в виде элементов массива.

Метод Split ищет разделители, выполняя сравнения с использованием правил порядковой сортировки с учетом регистра. Дополнительные сведения о сортировке слов, строк и порядковых номеров см. в перечислении System.Globalization.CompareOptions .

Метод Split игнорирует любой separator элемент, значение которого является null или пустая строка ("").

Чтобы избежать неоднозначных результатов, если строки в separator символах имеют общие символы, Split метод переходит от начала к концу значения экземпляра и соответствует первому элементу, separator который равен разделителю в экземпляре. Порядок, в котором встречаются подстроки в экземпляре, имеет приоритет над порядком элементов в separator.

Например, рассмотрим экземпляр, значение которого — abcdef. Если первый элемент в separator параметре "ef" и второй элемент был "bcde", результатом операции разделения будет "a" и "f". Это связано с тем, что подстрока в экземпляре "bcde" встречается и сопоставляется с элементом separator до обнаружения подстроки "f".

Однако если первый элемент separator был "bcd", а второй элемент был "bc", результатом операции разделения будет "a" и "ef". Это связано с тем, что "bcd" является первым разделителем в separator том, что соответствует разделителю в экземпляре. Если порядок разделителей был обратным, поэтому первый элемент был "bc" и второй элемент был "bcd", результатом будет "a" и "def".

Вопросы производительности

Методы Split выделяют память для возвращаемого объекта массива и String объекта для каждого элемента массива. Если приложению требуется оптимальная производительность или если управление выделением памяти имеет решающее значение в приложении, рассмотрите возможность использования IndexOf метода или IndexOfAny метода и при необходимости Compare для поиска подстроки в строке.

Если строка разбивается на символ разделителя, используйте IndexOf его или IndexOfAny метод для поиска символа-разделителя в строке. Если вы разделяете строку в строке разделителя, используйте метод или IndexOfAny для IndexOf поиска первого символа строки разделителя. Затем используйте метод, 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 является отрицательным значением.

options не является одним из значений StringSplitOptions.

Примеры

В следующем примере перечисление 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]>

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
 
// Display the array of separated strings using a local function
let show  (entries: string[]) =
    printfn $"The return value contains these {entries.Length} elements:"
    for entry in entries do
        printf $"<{entry}>"
    printf "\n\n"

let s1 = ",ONE,,TWO,,,THREE,,"
let s2 = "[stop]" +
         "ONE[stop][stop]" +
         "TWO[stop][stop][stop]" +
         "THREE[stop][stop]"
let charSeparators = [| ',' |]
let stringSeparators = [| "[stop]" |]
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
printfn "1) Split a string delimited by characters:\n"

// Display the original string and delimiter characters.
printfn $"1a) The original string is \"{s1}\"."
printfn $"The delimiter character is '{charSeparators[0]}'.\n"

// Split a string delimited by characters and return all elements.
printfn "1b) Split a string delimited by characters and return all elements:"
let result = s1.Split(charSeparators, StringSplitOptions.None)
show result

// Split a string delimited by characters and return all non-empty elements.
printfn "1c) Split a string delimited by characters and return all non-empty elements:"
let 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.
printfn "1d) Split a string delimited by characters and return 2 elements:"
let 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.
printfn "1e) Split a string delimited by characters and return 2 non-empty elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
printfn "2) Split a string delimited by another string:\n"

// Display the original string and delimiter string.
printfn $"2a) The original string is \"{s2}\"."
printfn $"The delimiter string is \"{stringSeparators[0]}\".\n"

// Split a string delimited by another string and return all elements.
printfn "2b) Split a string delimited by another string and return all elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.None)
show result

// Split the original string at the delimiter and return all non-empty elements.
printfn "2c) Split a string delimited by another string and return all non-empty elements:"
let 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.
printfn "2d) Split a string delimited by another string and return 2 elements:"
let 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.
printfn "2e) Split a string delimited by another string and return 2 non-empty elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

(*
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]>

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

'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);
let phrase = "The quick  brown fox"

phrase.Split(Unchecked.defaultof<char[]>, 3, StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split(null :> char[], 3, StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split((null: char[]), 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
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 Если параметр равен нулю или options параметр равен RemoveEmptyEntries нулю, а длина этого экземпляра равна нулю, возвращается пустой массив.

Каждый элемент separator определяет отдельный символ разделителя. options Если параметр имеет значение None, а два разделителя являются смежными или разделителем находятся в начале или конце этого экземпляра, соответствующий элемент массива содержитEmpty.

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

Если count значение больше числа подстрок, возвращаются доступные подстроки и исключение не возникает.

Вопросы производительности

Методы Split выделяют память для возвращаемого объекта массива и String объекта для каждого элемента массива. Если приложению требуется оптимальная производительность или если управление выделением памяти имеет решающее значение в приложении, рассмотрите возможность использования IndexOf метода или IndexOfAny метода и при необходимости Compare для поиска подстроки в строке.

Если строка разбивается на символ разделителя, используйте IndexOf его или IndexOfAny метод для поиска символа-разделителя в строке. Если вы разделяете строку в строке разделителя, используйте метод или IndexOfAny для IndexOf поиска первого символа строки разделителя. Затем используйте метод, 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. Дополнительные сведения см. в разделе "Примечания".

Атрибуты

Исключения

options не является одним из значений StringSplitOptions.

Примеры

В следующем примере показано различие в массивах, возвращаемых путем вызова метода строки 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'
let source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]"
let stringSeparators = [| "[stop]" |]

// Display the original string and delimiter string.
printfn $"Splitting the string:\n   \"{source}\".\n"
printfn $"Using the delimiter string:\n   \"{stringSeparators[0]}\"\n"

// Split a string delimited by another string and return all elements.
let result = source.Split(stringSeparators, StringSplitOptions.None)
printfn $"Result including all elements ({result.Length} elements):"
printf "   "
for s in result do
    printf $"""'{if String.IsNullOrEmpty s then "<>" else s}' """
printfn "\n"

// Split delimited by another string and return all non-empty elements.
let result = source.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
Console.WriteLine($"Result including non-empty elements ({result.Length} elements):")
printf "   "
for s in result do
    printf $"""'{if String.IsNullOrEmpty s then "<>" else s}' """
printfn ""

// 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]"
//    
//    let result including all elements (9 elements):
//       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
//    
//    let result including non-empty elements (3 elements):
//       'ONE' 'TWO' 'THREE'
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()

' 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
let separators = [| ","; "."; "!"; "?"; ""; ":"; " " |]
let value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate."
let words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries)
for word in words do
    printfn $"${word}"

// The example displays the following output:
//       The
//       handsome
//       energetic
//       young
//       dog
//       was
//       playing
//       with
//       his
//       smaller
//       more
//       lethargic
//       litter
//       mate
    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

' 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 длина этого экземпляра равна нулю, метод возвращает пустой массив.

Каждый элемент separator определяет отдельный разделитель, состоящий из одного или нескольких символов. options Если аргумент имеет значение None, а два разделителя являются смежными или разделителем находятся в начале или конце этого экземпляра, соответствующий элемент массива содержит String.Empty. Например, если separator включает два элемента : "-" и "_, значение экземпляра строки — "-_aa-_", а значение аргумента options — метод Noneвозвращает строковый массив со следующими пятью элементами:

  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);
let phrase = "The quick  brown fox"

phrase.Split(Unchecked.defaultof<string[]>, StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split(null :> string[], StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split((null: string[]), StringSplitOptions.RemoveEmptyEntries) |> ignore
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)

Сведения о сравнении

Метод Split извлекает подстроки в этой строке, разделенные одной или несколькими строками в параметре separator , и возвращает эти подстроки в виде элементов массива.

Метод Split ищет разделители, выполняя сравнения с использованием правил порядковой сортировки с учетом регистра. Дополнительные сведения о сортировке слов, строк и порядковых номеров см. в перечислении System.Globalization.CompareOptions .

Метод Split игнорирует любой separator элемент, значение которого является null или пустая строка ("").

Чтобы избежать неоднозначных результатов, если строки в separator символах имеют общие символы, Split операция выполняется с начала до конца значения экземпляра и соответствует первому элементу, separator который равен разделителю в экземпляре. Порядок, в котором встречаются подстроки в экземпляре, имеет приоритет над порядком элементов в separator.

Например, рассмотрим экземпляр, значение которого — abcdef. Если первый элемент в separator параметре "ef" и второй элемент был "bcde", результатом операции разделения будет строковый массив, содержащий два элемента: "a" и "f". Это связано с тем, что подстрока в экземпляре "bcde" встречается и сопоставляется с элементом separator до обнаружения подстроки "f".

Однако если первый элемент separator был "bcd", а второй элемент был "bc", результатом операции разделения будет строковый массив, содержащий два элемента: "a" и "ef". Это связано с тем, что "bcd" является первым разделителем в separator том, что соответствует разделителю в экземпляре. Если порядок разделителей был обратным, поэтому первый элемент был "bc", а второй элемент был "bcd", результатом будет строковый массив, содержащий два элемента: "a" и "def".

Вопросы производительности

Методы Split выделяют память для возвращаемого объекта массива и String объекта для каждого элемента массива. Если приложению требуется оптимальная производительность или если управление выделением памяти имеет решающее значение в приложении, рассмотрите возможность использования IndexOf метода или IndexOfAny метода и при необходимости Compare для поиска подстроки в строке.

Если строка разбивается на символ разделителя, используйте IndexOf его или IndexOfAny метод для поиска символа-разделителя в строке. Если вы разделяете строку в строке разделителя, используйте метод или IndexOfAny для IndexOf поиска первого символа строки разделителя. Затем используйте метод, 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[]

Массив, содержащий подстроки из этого экземпляра (не более count), разделенные символом separator.

Комментарии

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

Применяется к

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. Дополнительные сведения см. в разделе "Примечания".

Атрибуты

Исключения

options не является одним из значений StringSplitOptions.

Примеры

В следующем примере перечисление 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]>

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
 
// Display the array of separated strings using a local function
let show  (entries: string[]) =
    printfn $"The return value contains these {entries.Length} elements:"
    for entry in entries do
        printf $"<{entry}>"
    printf "\n\n"

let s1 = ",ONE,,TWO,,,THREE,,"
let s2 = "[stop]" +
         "ONE[stop][stop]" +
         "TWO[stop][stop][stop]" +
         "THREE[stop][stop]"
let charSeparators = [| ',' |]
let stringSeparators = [| "[stop]" |]
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
printfn "1) Split a string delimited by characters:\n"

// Display the original string and delimiter characters.
printfn $"1a) The original string is \"{s1}\"."
printfn $"The delimiter character is '{charSeparators[0]}'.\n"

// Split a string delimited by characters and return all elements.
printfn "1b) Split a string delimited by characters and return all elements:"
let result = s1.Split(charSeparators, StringSplitOptions.None)
show result

// Split a string delimited by characters and return all non-empty elements.
printfn "1c) Split a string delimited by characters and return all non-empty elements:"
let 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.
printfn "1d) Split a string delimited by characters and return 2 elements:"
let 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.
printfn "1e) Split a string delimited by characters and return 2 non-empty elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
printfn "2) Split a string delimited by another string:\n"

// Display the original string and delimiter string.
printfn $"2a) The original string is \"{s2}\"."
printfn $"The delimiter string is \"{stringSeparators[0]}\".\n"

// Split a string delimited by another string and return all elements.
printfn "2b) Split a string delimited by another string and return all elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.None)
show result

// Split the original string at the delimiter and return all non-empty elements.
printfn "2c) Split a string delimited by another string and return all non-empty elements:"
let 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.
printfn "2d) Split a string delimited by another string and return 2 elements:"
let 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.
printfn "2e) Split a string delimited by another string and return 2 non-empty elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

(*
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]>

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

'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 длина этого экземпляра равна нулю, метод возвращает пустой массив.

Каждый элемент separator определяет отдельный разделитель, состоящий из одного символа. options Если аргумент имеет значение None, а два разделителя являются смежными или разделителем находятся в начале или конце этого экземпляра, соответствующий элемент массива содержит String.Empty. Например, если separator включает два элемента '-' и '_'значение экземпляра строки равно "-_aa-_", а значение аргумента options равно None, метод возвращает массив строк со следующими пятью элементами:

  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);
let phrase = "The quick  brown fox"

phrase.Split(Unchecked.defaultof<char[]>, StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split(null :> char[], StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split((null: char[]), StringSplitOptions.RemoveEmptyEntries) |> ignore
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)

Сведения о сравнении

Метод Split извлекает подстроки в этой строке, разделенные одним или несколькими символами в параметре separator , и возвращает эти подстроки в виде элементов массива.

Метод Split ищет разделители, выполняя сравнения с использованием правил порядковой сортировки с учетом регистра. Дополнительные сведения о сортировке слов, строк и порядковых номеров см. в перечислении System.Globalization.CompareOptions .

Вопросы производительности

Методы Split выделяют память для возвращаемого объекта массива и String объекта для каждого элемента массива. Если приложению требуется оптимальная производительность или если управление выделением памяти имеет решающее значение в приложении, рассмотрите возможность использования IndexOf метода или IndexOfAny метода и при необходимости Compare для поиска подстроки в строке.

Если строка разбивается на символ разделителя, используйте IndexOf его или IndexOfAny метод для поиска символа-разделителя в строке. Если вы разделяете строку в строке разделителя, используйте метод или IndexOfAny для IndexOf поиска первого символа строки разделителя. Затем используйте метод, 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"
let name = "Alex Johnson III"

let subs = name.Split(null, 2)

let firstName = subs[0]
let lastName =
    if subs.Length > 1 then
        subs[1]
    else
        ""

// firstName = "Alex"
// lastName = "Johnson III"
Console.WriteLine("What is your name?")
Dim name As String = Console.ReadLine()

Dim substrings = name.Split(Nothing, 2)
Dim firstName As String = substrings(0)
Dim lastName As String

If substrings.Length > 1 Then
    lastName = substrings(1)
End If

' If the user enters "Alex Johnson III":
' firstName = "Alex"
' lastName = "Johnson III"

Комментарии

Символы-разделители не включаются в элементы возвращаемого массива.

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

separator Если параметр не содержит null символов, предполагается, что символы пробелов являются разделителями. Символы пробелов определяются стандартом Юникода Char.IsWhiteSpace , а метод возвращается true , если они передаются в него.

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

Если в этом экземпляре больше count подстрок, первые count - 1 подстроки возвращаются в первых count - 1 элементах возвращаемого значения, а остальные символы в этом экземпляре возвращаются в последнем элементе возвращаемого значения.

Если count значение больше числа подстрок, возвращаются доступные подстроки и исключение не возникает.

В следующей таблице приведены некоторые примеры.

Язык Строковое значение Separator Возвращаемый массив
C# "42, 12, 19" new Char[] {',', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char() = {","c," " "c}) {"42", "", "12", "", "19"}
C# "42..12..19." new Char[] {'.'} {"42", "", "12", "", "19", ""}
Visual Basic "42..12..19." Char() = {"." c} {"42", "", "12", "", "19", ""}
C# "Банан" new Char[] {'.'} {"Банан"}
Visual Basic "Банан" Char() = {"." c} {"Банан"}
C# "Дарб\nСмарба" new Char[] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char() = {} {"Darb", "Smarba"}
C# "Дарб\nСмарба" null {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nothing {"Darb", "Smarba"}

Вопросы производительности

Методы Split выделяют память для возвращаемого объекта массива и String объекта для каждого элемента массива. Если приложению требуется оптимальная производительность или если управление выделением памяти имеет решающее значение в приложении, рассмотрите возможность использования IndexOf метода или IndexOfAny метода и при необходимости Compare для поиска подстроки в строке.

Если строка разбивается на символ разделителя, используйте IndexOf его или IndexOfAny метод для поиска символа-разделителя в строке. Если вы разделяете строку в строке разделителя, используйте метод или IndexOfAny для IndexOf поиска первого символа строки разделителя. Затем используйте метод, 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
let s = "Today\tI'm going to school"
let subs = s.Split(' ', '\t')

for sub in subs do
    printfn $"Substring: {sub}"

// This example produces the following output:
//
// Substring: Today
// Substring: I'm
// Substring: going
// Substring: to
// Substring: school
Dim s As String = "Today" & vbTab & "I'm going to school"
Dim subs As String() = s.Split(" "c, Char.Parse(vbTab))

For Each substring In subs
    Console.WriteLine("Substring: " & substring)
Next

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

В следующей таблице показаны некоторые примеры.

Язык Строковое значение Separator Возвращенный массив
C# "42, 12, 19" new Char[] {',', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char() = {","c", "c}) {"42", "", "12", "", "19"}
C# "42..12..19." new Char[] {'.'} {"42", "", "12", "", "19", ""}
Visual Basic "42..12..19." Char() = {"." c} {"42", "", "12", "", "19", ""}
C# "Банан" new Char[] {'.'} {"Банан"}
Visual Basic "Банан" Char() = {"." c} {"Банан"}
C# "Дарб\nСмарба" new Char[] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char() = {} {"Darb", "Smarba"}
C# "Дарб\nСмарба" null {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nothing {"Darb", "Smarba"}

Массив разделителей

Каждый элемент разделителя определяет отдельный разделитель, состоящий из одного символа.

separator Если аргумент не содержит null символов, метод обрабатывает пробелы как разделители. Пробелы определяются стандартом Юникода, и Char.IsWhiteSpace метод возвращает true , если в него передается символ пробела.

String.Split(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.
let value = "This is a short string."
let delimiter = 's'
let substrings = value.Split delimiter
for substring in substrings do
    printfn $"{substring}"

// The example displays the following output:
//     Thi
//      i
//      a
//     hort
//     tring.
    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

' 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 оба метода используют идентичный набор символов пробелов Юникода.

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

Применяется к