String.Split Metoda

Definice

Vrátí pole řetězců, které obsahuje podřetězce v této instanci, které jsou oddělené prvky zadaného řetězce nebo pole znaků Unicode.

Přetížení

Split(Char, Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaného znaku oddělovače a volitelně možností. Rozdělí řetězec na maximální počet podřetězců na základě poskytnutého oddělovače znaků a volitelně vypouští prázdné podřetězce z výsledku.

Split(String[], Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaných oddělovacích řetězců a volitelně možností.

Split(Char[], Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaných oddělovacích znaků a volitelně možností.

Split(String[], StringSplitOptions)

Rozdělí řetězec na podřetězce na základě zadaného řetězce s oddělovači a volitelně možností.

Split(String, Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaného řetězce oddělovače a volitelně možností.

Split(Char[], StringSplitOptions)

Rozdělí řetězec na podřetězce na základě zadaných znaků oddělovače a možností.

Split(Char[], Int32)

Rozdělí řetězec na maximální počet podřetězců na základě zadaných oddělovacích znaků.

Split(Char, StringSplitOptions)

Rozdělí řetězec na podřetězce na základě zadaného znaku oddělovače a volitelně možnosti.

Split(String, StringSplitOptions)

Rozdělí řetězec na podřetězce založené na zadaném oddělovači řetězců.

Split(Char[])

Rozdělí řetězec na podřetězce na základě zadaných oddělovacích znaků.

Poznámky

Split se používá k přerušení řetězce s oddělovači na podřetězce. Pole znaků nebo pole řetězců můžete použít k určení nuly nebo více oddělovacích znaků nebo řetězců. Pokud nejsou zadány žádné oddělovací znaky, rozdělí se řetězec prázdnými znaky.

Přetížení metody umožňuje omezit počet podřetězců vrácených metodou (metoda) a určit, jestli se mají do výsledku zahrnout prázdné řetězce nebo dílčí řetězce trim (metody a), nebo jak to udělat Split Split(Char[], Int32) Split(Char[], StringSplitOptions) Split(String[], StringSplitOptions) (metody Split(Char[], Int32, StringSplitOptions) a Split(String[], Int32, StringSplitOptions) ).

Tip

Metoda není vždy nejlepším způsobem, jak rozdělit řetězec s Split oddělovači na podřetězce. Pokud nechcete extrahovat všechny podřetězce řetězce s oddělovači nebo chcete analyzovat řetězec na základě vzoru místo sady znaků oddělovače, zvažte použití regulárních výrazů nebo zkombinujte jednu z metod vyhledávání, které vrací index znaku s Substring metodou . Další informace najdete v tématu Extrakce podřetězců z řetězce.

Příklad

Následující příklady ukazují tři různá přetížení String.Split() . První příklad volá Split(Char[]) přetížení a předá jeden oddělovač.

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.

Jak vidíte, znaky tečky ( . ) jsou součástí dvou podřetězců. Pokud chcete vyloučit znaky tečky, můžete přidat znak tečky jako další znak oddělovače. Další příklad ukazuje, jak to provést.

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:

Tečky jsou mimo podřetězce, ale teď byly zahrnuty dva extra prázdné podřetězce. Tento prázdný podřetězec představuje podřetězec mezi slovem a tečkou, která ho následuje. Pokud chcete vyprázdnit prázdné podřetězce z výsledného pole, můžete zavolat přetížení a Split(Char[], StringSplitOptions) StringSplitOptions.RemoveEmptyEntries zadat parametr 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

Oddíly pro jednotlivá přetížení obsahují String.Split() další příklady.

Split(Char, Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaného znaku oddělovače a volitelně možností. Rozdělí řetězec na maximální počet podřetězců na základě poskytnutého oddělovače znaků a volitelně vypouští prázdné podřetězce z výsledku.

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

Parametry

separator
Char

Znak, který odděluje podřetězce v této instanci.

count
Int32

Maximální počet prvků očekávaných v poli

options
StringSplitOptions

Bitová kombinace hodnot výčtu, která určuje, zda se mají dílčí řetězce oříznout a zahrnout prázdné podřetězce.

Návraty

String[]

Pole obsahující nejvíce count podřetězců z této instance, které jsou oddělené hodnotou separator .

Poznámky

Pokud už byl řetězec rozdělený – 1krát, ale nedosáhl se konce řetězce, bude poslední řetězec ve vráceném poli obsahovat zbývající koncový podřetězec této instance count beze změny.

Platí pro

Split(String[], Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaných oddělovacích řetězců a volitelně možností.

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

Parametry

separator
String[]

Řetězce, které oddělí podřetězce v tomto řetězci, prázdné pole, které neobsahuje žádné oddělovače, nebo null .

count
Int32

Maximální počet podřetězců, které se vrátí.

options
StringSplitOptions

Bitová kombinace hodnot výčtu, která určuje, zda se mají dílčí řetězce oříznout a zahrnout prázdné podřetězce.

Návraty

String[]

Pole, jehož prvky obsahují podřetězce v tomto řetězci, které jsou oddělené jedním nebo více řetězci v separator . Další informace najdete v části Poznámky.

Atributy

Výjimky

count je záporná.

options není jednou z StringSplitOptions hodnot.

Příklady

Následující příklad používá výčet StringSplitOptions k zahrnutí nebo vyloučení podřetězců generovaných Split metodou.

// 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]>

*/

Poznámky

Oddělovače řetězce nejsou zahrnuty v prvcích vráceného pole.

Pokud tato instance neobsahuje žádný z řetězců v nebo je parametr 1, vrácené pole se skládá z jediného separator count prvku, který obsahuje tuto instanci.

Pokud je parametr nebo neobsahuje žádné znaky, předpokládá se, že prázdné znaky separator null jsou oddělovače. Prázdné znaky jsou definovány standardem Unicode a metoda je vrátí, Char.IsWhiteSpace true pokud jsou předány.

Chcete-li předat parametr, je nutné určit typ k rozlišení volání z některých jiných null string[] separator null přetížení, například Split(Char[], Int32, StringSplitOptions) . Následující příklad ukazuje několik způsobů k jednoznačné identifikaci tohoto přetížení.

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

Pokud je parametr nula nebo je parametr a délka této instance je nula, vrátí se count options prázdné RemoveEmptyEntries pole.

Každý prvek definuje samostatný oddělovač, který se separator skládá z jednoho nebo více znaků. Pokud je parametr a dva oddělovače jsou sousedící nebo je na začátku nebo na konci této instance nalezen oddělovač, odpovídající options None prvek pole obsahuje Empty .

Pokud je v tomto případě více než podřetězců, vrátí se první podřetězce minus 1 v prvních minus 1 prvcích návratové hodnoty a zbývající znaky v této instanci se vrátí v posledním prvku vrácené count count count hodnoty.

Pokud je větší než počet podřetězců, vrátí se dostupné count podřetězce a není vyvolána žádná výjimka.

Pole oddělovače

Pokud se kterýkoli z prvků separator v sestává z více znaků, je celý podřetězec považován za oddělovač. Pokud je například jeden z prvků v souboru "10", pokusí se rozdělit separator řetězec "This10is10a10string". vrátí toto pole se čtyřmi prvky: { "This", "is", "a", "string". }.

Podrobnosti porovnání

Metoda extrahuje podřetězce v tomto řetězci, které jsou oddělené jedním nebo více řetězci v parametru, a vrátí tyto podřetězce jako prvky Split separator pole.

Metoda hledá oddělovače provedením porovnání s použitím pravidel řadového řazení s rozlišování malých Split a malých písmen. Další informace o řazení slov, řetězců a řadových řad najdete ve System.Globalization.CompareOptions výčtu.

Metoda Split ignoruje libovolný separator prvek, jehož hodnota je null , nebo prázdný řetězec ("").

Aby nedocházelo k nejednoznačnosti výsledků, když řetězce v souboru mají společné znaky, metoda pokračuje od začátku do konce hodnoty instance a odpovídá prvnímu prvku v řetězci , který se rovná oddělovači v separator Split separator instanci. Pořadí, ve kterém jsou v instanci zjištěny podřetězce, má přednost před pořadím prvků v separator .

Představte si například instanci, jejíž hodnota je "abcdef". Pokud byl první prvek v souboru "ef" a druhý prvek byl "bcde", výsledkem operace rozdělení by byly separator "a" a "f". Je to proto, že je zjištěn podřetězec v instanci "bcde" a odpovídá elementu v před výskytem podřetězce separator "f".

Pokud byl ale první prvek v souboru "bcd" a druhý prvek byl "bc", výsledkem operace rozdělení by byla separator "a" a "ef". Je to proto, že "bcd" je první oddělovač v , který odpovídá separator oddělovači v instanci. Pokud bylo pořadí oddělovačů obráceno, takže první prvek byl "bc" a druhý prvek byl "bcd", výsledkem by byla "a" a "def".

Otázky výkonu

Metody Split přidělují paměť pro vrácený objekt pole a String objekt pro každý prvek pole. Pokud vaše aplikace vyžaduje optimální výkon nebo pokud je správa přidělení paměti v aplikaci kritická, zvažte použití metody nebo a volitelně metody k vyhledání podřetězce IndexOf IndexOfAny v Compare řetězci.

Pokud rozdělíte řetězec znakem oddělovače, použijte k vyhledání znaku oddělovače v řetězci IndexOf IndexOfAny metodu nebo . Pokud rozdělíte řetězec v řetězci oddělovače, pomocí metody nebo vyhledejte první IndexOf IndexOfAny znak řetězce oddělovače. Potom pomocí metody určete, jestli se znaky za prvním znakem rovnají zbývajícím Compare znakům řetězce oddělovače.

Pokud se navíc k rozdělení řetězců ve více voláních metod používá stejná sada znaků, zvažte vytvoření jednoho pole a odkazování na něj v každém Split volání metody. To významně snižuje režii dalšího volání metody.

Poznámky pro volající

V .NET Framework 3.5 a starších verzích, pokud je metodě předána metoda , která je nebo neobsahuje žádné znaky, používá metoda k rozdělení řetězce mírně odlišnou sadu prázdných znaků než metoda k oříznutí Split(Char[]) separator null Trim(Char[]) řetězce. Počínaje .NET Framework 4 používají obě metody stejnou sadu prázdného znaku Unicode.

Platí pro

Split(Char[], Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaných oddělovacích znaků a volitelně možností.

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

Parametry

separator
Char[]

Pole znaků, které odděluje podřetězce v tomto řetězci, prázdné pole, které neobsahuje žádné oddělovače, nebo null .

count
Int32

Maximální počet podřetězců, které se vrátí.

options
StringSplitOptions

Bitová kombinace hodnot výčtu, která určuje, zda se mají dílčí řetězce oříznout a zahrnout prázdné podřetězce.

Návraty

String[]

Pole obsahující podřetězce v tomto řetězci, které jsou oddělené jedním nebo více znaky v separator . Další informace najdete v části Poznámky.

Atributy

Výjimky

count je záporná.

options není jednou z StringSplitOptions hodnot.

Příklady

Následující příklad používá výčet StringSplitOptions k zahrnutí nebo vyloučení podřetězců generovaných Split metodou.

// 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]>

*/

Poznámky

Znaky oddělovače nejsou zahrnuty v prvcích vráceného pole.

Pokud tato instance v neobsahuje žádné znaky nebo je parametr 1, vrácené pole se skládá z jediného separator count prvku, který obsahuje tuto instanci.

Pokud je parametr nebo neobsahuje žádné znaky, předpokládá se, že prázdné znaky separator null jsou oddělovače. Prázdné znaky jsou definovány standardem Unicode a metoda je vrátí, Char.IsWhiteSpace true pokud jsou předány.

Chcete-li předat parametr, je nutné určit typ k rozlišení volání z některých jiných null char[] separator null přetížení, například Split(String[], Int32, StringSplitOptions) . Následující příklad ukazuje několik způsobů k jednoznačné identifikaci tohoto přetížení.

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

Pokud je parametr nula nebo je parametr a délka této instance je nula, vrátí se count options prázdné RemoveEmptyEntries pole.

Každý prvek separator definuje samostatný znak oddělovače. Pokud je parametr a dva oddělovače jsou sousedící nebo je na začátku nebo na konci této instance nalezen oddělovač, odpovídající options None prvek pole obsahuje Empty .

Pokud je v tomto případě více než podřetězců, vrátí se první podřetězce minus 1 v prvních minus 1 prvcích návratové hodnoty a zbývající znaky v této instanci se vrátí v posledním prvku vrácené count count count hodnoty.

Pokud je větší než počet podřetězců, vrátí se dostupné count podřetězce a není vyvolána žádná výjimka.

Otázky výkonu

Metody Split přidělují paměť pro vrácený objekt pole a String objekt pro každý prvek pole. Pokud vaše aplikace vyžaduje optimální výkon nebo pokud je správa přidělení paměti v aplikaci kritická, zvažte použití metody nebo a volitelně metody k vyhledání podřetězce IndexOf IndexOfAny v Compare řetězci.

Pokud rozdělíte řetězec znakem oddělovače, použijte k vyhledání znaku oddělovače v řetězci IndexOf IndexOfAny metodu nebo . Pokud rozdělíte řetězec v řetězci oddělovače, pomocí metody nebo vyhledejte první IndexOf IndexOfAny znak řetězce oddělovače. Potom pomocí metody určete, jestli se znaky za prvním znakem rovnají zbývajícím Compare znakům řetězce oddělovače.

Pokud se navíc k rozdělení řetězců ve více voláních metod používá stejná sada znaků, zvažte vytvoření jednoho pole a odkazování na něj v každém Split volání metody. To významně snižuje režii dalšího volání metody.

Poznámky pro volající

V .NET Framework 3.5 a starších verzích, pokud je metodě předána metoda , která je nebo neobsahuje žádné znaky, používá metoda k rozdělení řetězce mírně odlišnou sadu prázdných znaků než metoda k oříznutí Split(Char[]) separator null Trim(Char[]) řetězce. Počínaje .NET Framework 4 používají obě metody stejnou sadu prázdného znaku Unicode.

Platí pro

Split(String[], StringSplitOptions)

Rozdělí řetězec na podřetězce na základě zadaného řetězce s oddělovači a volitelně možností.

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

Parametry

separator
String[]

Pole řetězců, které odděluje podřetězce v tomto řetězci, prázdné pole, které neobsahuje žádné oddělovače, nebo null .

options
StringSplitOptions

Bitová kombinace hodnot výčtu, která určuje, zda se mají dílčí řetězce oříznout a zahrnout prázdné podřetězce.

Návraty

String[]

Pole, jehož prvky obsahují podřetězce v tomto řetězci, které jsou oddělené jedním nebo více řetězci v separator . Další informace najdete v části Poznámky.

Atributy

Výjimky

options není jednou z StringSplitOptions hodnot.

Příklady

Následující příklad ukazuje rozdíl v polích vrácených voláním metody řetězce s jeho parametrem String.Split(String[], StringSplitOptions) options roven a 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'

Následující příklad definuje pole oddělovačů, které obsahují interpunkci a prázdné znaky. Předání tohoto pole spolu s hodnotou do metody vrátí pole, které se skládá z StringSplitOptions.RemoveEmptyEntries Split(String[], StringSplitOptions) jednotlivých slov z řetězce.

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

Všimněte si, že metoda je volána options s argumentem nastaveným na StringSplitOptions.RemoveEmptyEntries . To brání vrácenému poli v zahrnutí hodnot, které představují prázdné shody podřetězců mezi interpunkční znaky a String.Empty prázdnými znaky.

Poznámky

Pokud je řetězec oddělený známou sadu řetězců, můžete ho pomocí metody Split oddělit do podřetězců.

Oddělovače řetězce nejsou zahrnuty v prvcích vráceného pole. Pokud například pole obsahuje řetězec "--" a hodnota aktuální instance řetězce je "aa--bb--cc", vrátí metoda pole, které obsahuje tři separator prvky: "aa", "bb" a "cc".

Pokud tato instance neobsahuje žádný z řetězců v , vrácené pole se separator skládá z jednoho prvku, který obsahuje tuto instanci.

Pokud je options parametr a délka této instance je RemoveEmptyEntries nula, vrátí metoda prázdné pole.

Každý prvek definuje samostatný oddělovač, který se separator skládá z jednoho nebo více znaků. Pokud je argument a dva oddělovače jsou sousedící nebo je na začátku nebo na konci této instance nalezen oddělovač, odpovídající options None prvek pole obsahuje String.Empty . Pokud například obsahuje dva prvky, "-" a " ", hodnota instance řetězce je separator _ "- _ aa- " a hodnota _ argumentu je options , metoda vrátí pole řetězců s následujícími pěti None prvky:

  1. String.Empty, který představuje prázdný řetězec, který předchází podřetězci "-" v indexu 0.

  2. String.Empty, která představuje prázdný řetězec mezi podřetězci "-" na indexu 0 a podřetězci "_" na indexu 1.

  3. "aa".

  4. String.Empty, který představuje prázdný řetězec, který následuje podřetězec "-" na indexu 4.

  5. String.Empty, který představuje prázdný řetězec, který následuje podřetězec "_" na indexu 5.

Pole oddělovače

Pokud se kterýkoli z prvků separator v sestává z více znaků, je celý podřetězec považován za oddělovač. Pokud je například jeden z prvků v souboru "10", pokusí se rozdělit separator řetězec "This10is10a10string". vrátí následující pole se čtyřmi prvky: { "This", "is", "a", "string". }.

Pokud je separator parametr nebo neobsahuje žádné neprázdné řetězce, předpokládá se, že prázdné znaky jsou null oddělovače. Prázdné znaky jsou definovány standardem Unicode a metoda je vrátí, Char.IsWhiteSpace true pokud jsou předány.

Chcete-li předat parametr, je nutné určit typ k rozlišení volání z některých jiných null string[] separator null přetížení, například Split(Char[], StringSplitOptions) . Následující příklad ukazuje několik způsobů k jednoznačné identifikaci tohoto přetížení.

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

Podrobnosti porovnání

Metoda extrahuje podřetězce v tomto řetězci, které jsou oddělené jedním nebo více řetězci v parametru, a vrátí tyto podřetězce jako prvky Split separator pole.

Metoda hledá oddělovače provedením porovnání s použitím pravidel řadového řazení s rozlišování malých Split a malých písmen. Další informace o řazení slov, řetězců a řadových řad najdete ve System.Globalization.CompareOptions výčtu.

Metoda Split ignoruje libovolný separator prvek, jehož hodnota je null , nebo prázdný řetězec ("").

Aby se zabránilo nejednoznačnosti výsledků, když řetězce v souboru mají společné znaky, operace pokračuje od začátku do konce hodnoty instance a odpovídá prvnímu prvku v , který se rovná oddělovači v separator Split separator instanci. Pořadí, ve kterém jsou v instanci zjištěny podřetězce, má přednost před pořadím prvků v separator .

Představte si například instanci, jejíž hodnota je "abcdef". Pokud byl první prvek v souboru "ef" a druhý prvek byl "bcde", výsledkem operace rozdělení by bylo pole řetězců, které obsahuje dva separator prvky, "a" a "f". Je to proto, že je zjištěn podřetězec v instanci "bcde" a odpovídá elementu v před výskytem podřetězce separator "f".

Pokud byl ale první prvek v souboru "bcd" a druhý prvek byl "bc", výsledkem operace rozdělení by bylo pole řetězců, které obsahuje dva separator prvky, "a" a "ef". Je to proto, že "bcd" je první oddělovač v , který odpovídá separator oddělovači v instanci. Pokud bylo pořadí oddělovačů obráceno, takže první prvek byl "bc" a druhý prvek byl "bcd", výsledkem by bylo pole řetězců, které obsahuje dva prvky, "a" a "def".

Otázky výkonu

Metody Split přidělují paměť pro vrácený objekt pole a String objekt pro každý prvek pole. Pokud vaše aplikace vyžaduje optimální výkon nebo pokud je správa přidělení paměti v aplikaci kritická, zvažte použití metody nebo a volitelně metody k vyhledání podřetězce IndexOf IndexOfAny v Compare řetězci.

Pokud rozdělíte řetězec znakem oddělovače, použijte k vyhledání znaku oddělovače v řetězci IndexOf IndexOfAny metodu nebo . Pokud rozdělíte řetězec v řetězci oddělovače, pomocí metody nebo vyhledejte první IndexOf IndexOfAny znak řetězce oddělovače. Potom pomocí metody určete, jestli se znaky za prvním znakem rovnají zbývajícím Compare znakům řetězce oddělovače.

Pokud se navíc k rozdělení řetězců ve více voláních metod používá stejná sada znaků, zvažte vytvoření jednoho pole a odkazování na něj v každém Split volání metody. To významně snižuje režii dalšího volání metody.

Poznámky pro volající

V .NET Framework 3.5 a starších verzích, pokud je metodě předána metoda , která je nebo neobsahuje žádné znaky, používá metoda k rozdělení řetězce mírně odlišnou sadu prázdných znaků než metoda k oříznutí Split(Char[]) separator null Trim(Char[]) řetězce. Počínaje .NET Framework 4 používají obě metody stejnou sadu prázdného znaku Unicode.

Platí pro

Split(String, Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaného řetězce oddělovače a volitelně možností.

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

Parametry

separator
String

Řetězec, který v této instanci odděluje podřetězce.

count
Int32

Maximální počet prvků očekávaných v poli

options
StringSplitOptions

Bitová kombinace hodnot výčtu, která určuje, zda se mají dílčí řetězce oříznout a zahrnout prázdné podřetězce.

Návraty

String[]

Pole obsahující nejvíce count podřetězců z této instance, které jsou oddělené hodnotou separator .

Poznámky

Pokud už byl řetězec rozdělený – 1krát, ale nedosáhl se konce řetězce, bude poslední řetězec ve vráceném poli obsahovat zbývající koncový podřetězec této instance count beze změny.

Platí pro

Split(Char[], StringSplitOptions)

Rozdělí řetězec na podřetězce na základě zadaných znaků oddělovače a možností.

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

Parametry

separator
Char[]

Pole znaků, které vymezují podřetězce v tomto řetězci, prázdné pole obsahující žádné oddělovače nebo null .

options
StringSplitOptions

Bitová kombinace hodnot výčtu, která určuje, zda se mají oříznout podřetězce a zahrnout prázdné podřetězce.

Návraty

String[]

Pole, jehož prvky obsahují podřetězce v tomto řetězci, které jsou odděleny jedním nebo více znaky v separator . Další informace najdete v části poznámky.

Atributy

Výjimky

options není jednou z StringSplitOptions hodnot.

Příklady

Následující příklad používá výčet StringSplitOptions k zahrnutí nebo vyloučení podřetězců generovaných Split metodou.

// 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]>

*/

Poznámky

Znaky oddělovače (znaky v separator poli) nejsou zahrnuty do prvků vráceného pole. Například pokud separator pole obsahuje znak "-" a hodnotu aktuální instance řetězce je "AA-BB-CC", metoda vrátí pole, které obsahuje tři prvky: "AA", "BB" a "CC".

Pokud tato instance neobsahuje žádný ze znaků v separator , vrácené pole se skládá z jednoho prvku, který obsahuje tuto instanci.

Pokud options je parametr RemoveEmptyEntries a délka této instance je nula, metoda vrátí prázdné pole.

Každý prvek separator definuje samostatný oddělovač, který se skládá z jednoho znaku. Pokud options je argument None a dva oddělovače jsou sousední nebo na začátku nebo konci této instance byl nalezen oddělovač, odpovídající prvek pole obsahuje String.Empty . Například pokud separator obsahuje dva prvky, '-' a '_' , hodnota instance řetězce je "- _ AA- _ " a hodnota options argumentu je None , metoda vrátí pole řetězce s následujícími pěti prvky:

  1. String.Empty, který představuje prázdný řetězec, který předchází znak "-" na indexu 0.

  2. String.Empty, který představuje prázdný řetězec mezi znakem "-" na indexu 0 a znakem "_" na indexu 1.

  3. "AA".

  4. String.Empty, který představuje prázdný řetězec, který následuje znak "-" na indexu 4.

  5. String.Empty, který představuje prázdný řetězec, který následuje znak "_" na indexu 5.

Pole oddělovače

Pokud separator je parametr null nebo neobsahuje žádné znaky, považují se prázdné znaky za oddělovače. Prázdné znaky jsou definovány standardem Unicode a metoda je vrátí, Char.IsWhiteSpace true pokud jsou předány.

Chcete-li předat parametr, je nutné určit typ k rozlišení volání z některých jiných null char[] separator null přetížení, například Split(String[], StringSplitOptions) . Následující příklad ukazuje několik způsobů k jednoznačné identifikaci tohoto přetížení.

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

Podrobnosti porovnání

Metoda extrahuje podřetězce v tomto řetězci, které jsou oddělené jedním nebo více znaky v parametru, a vrátí tyto podřetězce jako prvky Split separator pole.

Metoda hledá oddělovače provedením porovnání s použitím pravidel řadového řazení s rozlišování malých Split a malých písmen. Další informace o řazení slov, řetězců a řadových řad najdete ve System.Globalization.CompareOptions výčtu.

Otázky výkonu

Metody Split přidělují paměť pro vrácený objekt pole a String objekt pro každý prvek pole. Pokud vaše aplikace vyžaduje optimální výkon nebo pokud je správa přidělení paměti v aplikaci kritická, zvažte použití metody nebo a volitelně metody k vyhledání podřetězce IndexOf IndexOfAny v Compare řetězci.

Pokud rozdělíte řetězec znakem oddělovače, použijte k vyhledání znaku oddělovače v řetězci IndexOf IndexOfAny metodu nebo . Pokud rozdělíte řetězec v řetězci oddělovače, pomocí metody nebo vyhledejte první IndexOf IndexOfAny znak řetězce oddělovače. Potom pomocí metody určete, jestli se znaky za prvním znakem rovnají zbývajícím Compare znakům řetězce oddělovače.

Pokud se navíc k rozdělení řetězců ve více voláních metod používá stejná sada znaků, zvažte vytvoření jednoho pole a odkazování na něj v každém Split volání metody. To významně snižuje režii dalšího volání metody.

Poznámky pro volající

V .NET Framework 3.5 a starších verzích, pokud je metodě předána metoda , která je nebo neobsahuje žádné znaky, používá metoda k rozdělení řetězce mírně odlišnou sadu prázdných znaků než metoda k oříznutí Split(Char[]) separator null Trim(Char[]) řetězce. Počínaje .NET Framework 4 používají obě metody stejnou sadu prázdného znaku Unicode.

Platí pro

Split(Char[], Int32)

Rozdělí řetězec na maximální počet podřetězců na základě zadaných oddělovacích znaků.

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

Parametry

separator
Char[]

Pole znaků, které vymezují podřetězce v tomto řetězci, prázdné pole obsahující žádné oddělovače nebo null .

count
Int32

Maximální počet podřetězců, které se mají vrátit.

Návraty

String[]

Pole, jehož prvky obsahují podřetězce v této instanci, které jsou odděleny jedním nebo více znaky v separator . Další informace najdete v části poznámky.

Výjimky

count je záporné.

Příklady

Následující příklad ukazuje, jak count lze použít k omezení počtu řetězců vrácených 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"

Poznámky

Znaky oddělovače nejsou zahrnuty v prvcích vráceného pole.

Pokud tato instance neobsahuje žádný ze znaků v separator , vrácené pole se skládá z jednoho prvku, který obsahuje tuto instanci. Pokud count je nula, vrátí se prázdné pole.

Pokud separator je parametr null nebo neobsahuje žádné znaky, považují se prázdné znaky za oddělovače. Prázdné znaky jsou definovány standardem Unicode a metoda se vrátí, Char.IsWhiteSpace true Pokud jsou předány do ní.

Každý prvek separator definuje samostatný oddělovač znaků. Pokud dva oddělovače jsou sousední nebo je oddělovač nalezen na začátku nebo konci této instance, obsahuje odpovídající prvek pole Empty .

Pokud je count v této instanci více než podřetězce, count - 1 jsou první podřetězce vráceny v prvním count - 1 elementu návratové hodnoty a zbývající znaky v této instanci jsou vráceny v posledním prvku návratové hodnoty.

Pokud count je větší než počet podřetězců, jsou dostupné podřetězce vráceny a není vyvolána žádná výjimka.

V následující tabulce jsou uvedeny některé příklady.

Jazyk Řetězcová hodnota Oddělovač Vrácené pole
C# "42, 12, 19" nový znak [] {', ', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char () = {"," c, "" c}) {"42", "", "12", "", "19"}
C# "42.. 12.. 19" nový znak [] {'. '} {"42", "", "12", "", "19", ""}
Visual Basic "42.. 12.. 19" Char () = {"." r {"42", "", "12", "", "19", ""}
C# Banán nový znak [] {'. '} {"Banán"}
Visual Basic Banán Char () = {"." r {"Banán"}
C# "Darb\nSmarba" New Char [] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char () = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" null {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nothing {"Darb", "Smarba"}

Otázky výkonu

SplitMetody přidělují paměť pro vrácený objekt Array a String objekt pro každý prvek pole. Pokud vaše aplikace vyžaduje optimální výkon nebo pokud je v aplikaci důležité spravovat přidělování paměti, zvažte použití IndexOf IndexOfAny metody nebo a volitelně také Compare metodu k vyhledání podřetězce v rámci řetězce.

Pokud je řetězec rozdělen znakem oddělovače, použijte IndexOf IndexOfAny metodu nebo k vyhledání znaku oddělovače v řetězci. Pokud je řetězec rozdělen do oddělovače, použijte IndexOf IndexOfAny metodu nebo k vyhledání prvního znaku oddělovače řetězce. Pak použijte Compare metodu k určení, zda znaky za tímto prvním znakem jsou rovny zbývajícím znakům řetězce oddělovače.

Kromě toho, pokud je použita stejná sada znaků k rozdělení řetězců ve více Split voláních metod, zvažte vytvoření jednoho pole a odkazování na něj v každém volání metody. To významně snižuje režii dalšího volání metody.

Poznámky pro volající

v .NET Framework 3,5 a starších verzích, pokud Split(Char[]) je metoda předána typu separator , který je null nebo neobsahuje žádné znaky, metoda používá mírně odlišnou sadu prázdných znaků pro rozdělení řetězce, než Trim(Char[]) metoda provede oříznutí řetězce. počínaje .NET Framework 4 obě metody používají stejnou sadu prázdných znaků Unicode.

Viz také

Platí pro

Split(Char, StringSplitOptions)

Rozdělí řetězec na podřetězce na základě zadaného znaku oddělovače a volitelně možnosti.

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

Parametry

separator
Char

Znak, který odděluje podřetězce v tomto řetězci.

options
StringSplitOptions

Bitová kombinace hodnot výčtu, která určuje, zda se mají oříznout podřetězce a zahrnout prázdné podřetězce.

Návraty

String[]

Pole, jehož prvky obsahují podřetězce z této instance, které jsou odděleny separator .

Platí pro

Split(String, StringSplitOptions)

Rozdělí řetězec na podřetězce založené na zadaném oddělovači řetězců.

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

Parametry

separator
String

Řetězec, který odděluje podřetězce v tomto řetězci.

options
StringSplitOptions

Bitová kombinace hodnot výčtu, která určuje, zda se mají dílčí řetězce oříznout a zahrnout prázdné podřetězce.

Návraty

String[]

Pole, jehož prvky obsahují podřetězce z této instance, které jsou oddělené separator hodnotou .

Platí pro

Split(Char[])

Rozdělí řetězec na podřetězce na základě zadaných oddělovacích znaků.

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

Parametry

separator
Char[]

Pole oddělující znaky, prázdné pole, které neobsahuje žádné oddělovače, nebo null .

Návraty

String[]

Pole, jehož prvky obsahují podřetězce z této instance, které jsou odděleny jedním nebo více znaky v separator . Další informace najdete v části Poznámky.

Příklady

Následující příklad ukazuje, jak extrahovat jednotlivá slova z bloku textu tím, že zpracovává znak mezery ( ) a znak tabulátoru ( \t ) jako oddělovače. Řetězec, který se má rozdělit, zahrnuje oba tyto znaky.

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

Poznámky

Pokud je řetězec oddělený známou sadu znaků, můžete ho pomocí metody oddělit Split(Char[]) do podřetězců.

Znaky oddělovače nejsou zahrnuty v prvcích vráceného pole. Pokud například pole oddělovače obsahuje znak "-" a hodnota aktuální instance řetězce je "aa-bb-cc", vrátí metoda pole, které obsahuje tři prvky: "aa", "bb" a "cc".

Pokud tato instance neobsahuje žádné znaky v , vrácené separator pole se skládá z jednoho prvku, který obsahuje tuto instanci.

Každý prvek separator definuje samostatný znak oddělovače. Pokud dva oddělovače sousedí nebo je na začátku nebo na konci této instance nalezen oddělovač, odpovídající prvek ve vráceném poli obsahuje Empty .

V následující tabulce jsou uvedeny některé příklady.

Jazyk Řetězcová hodnota Oddělovač Vrácené pole
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# "Banán" new Char[] {'.'} {"Banana"}
Visual Basic "Banán" Char() = {"." c} {"Banana"}
C# "Darb\nSmarba" new Char[] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char() = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" null {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nothing {"Darb", "Smarba"}

Pole oddělovače

Každý prvek oddělovače definuje samostatný oddělovač, který se skládá z jednoho znaku.

Pokud je argument nebo neobsahuje žádné znaky, metoda považuje prázdné separator null znaky za oddělovače. Prázdné znaky jsou definovány standardem Unicode a metoda vrátí, pokud je do něj předán Char.IsWhiteSpace true mezerný znak.

String.Split(Char[]) a překlad přetížení kompilátoru

I když je jediným parametrem pro toto přetížení pole znaků, můžete ho volat jedním znakem, jak String.Split ukazuje následující příklad.

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.

Vzhledem k tomu, že parametr je dekorován atributem , kompilátory interpretují jeden znak jako pole separator ParamArrayAttribute znaků s jedním prvkem. To není případ jiných přetížení, která zahrnují parametr. Tato přetížení je nutné explicitně předat jako String.Split separator argument pole separator znaků.

Podrobnosti porovnání

Metoda extrahuje podřetězce v tomto řetězci, které jsou oddělené jedním nebo více znaky v poli, a vrátí tyto podřetězce jako prvky Split(Char[]) separator pole.

Metoda hledá oddělovače provedením porovnání s použitím pravidel řadového řazení s rozlišování malých Split(Char[]) a malých písmen. Další informace o řazení slov, řetězců a řadových řad najdete ve System.Globalization.CompareOptions výčtu.

Otázky výkonu

Metody Split přidělují paměť pro vrácený objekt pole a String objekt pro každý prvek pole. Pokud vaše aplikace vyžaduje optimální výkon nebo pokud je správa přidělení paměti v aplikaci kritická, zvažte použití IndexOf metody IndexOfAny nebo . Můžete také použít metodu k vyhledání Compare podřetězce v řetězci.

Pokud chcete řetězec rozdělit pomocí znaku oddělovače, pomocí metody nebo vyhledejte v IndexOf IndexOfAny řetězci znak oddělovače. Pokud chcete řetězec rozdělit na řetězec oddělovače, pomocí metody nebo vyhledejte první IndexOf IndexOfAny znak řetězce oddělovače. Potom pomocí metody určete, jestli se znaky za prvním znakem rovnají zbývajícím Compare znakům řetězce oddělovače.

Kromě toho, pokud je použita stejná sada znaků k rozdělení řetězců ve více Split voláních metod, zvažte vytvoření jednoho pole a odkazování na něj v každém volání metody. To významně snižuje režii dalšího volání metody.

Poznámky pro volající

v .NET Framework 3,5 a starších verzích, pokud Split(Char[]) je metoda předána typu separator , který je null nebo neobsahuje žádné znaky, metoda používá mírně odlišnou sadu prázdných znaků pro rozdělení řetězce, než Trim(Char[]) metoda provede oříznutí řetězce. počínaje .NET Framework 4 obě metody používají stejnou sadu prázdných znaků Unicode.

Viz také

Platí pro