String.Split Metoda

Definice

Vrátí pole řetězce, které obsahuje podřetězce v této instanci, které jsou odděleny elementy zadaného řetězce nebo pole znaků Unicode.Returns a string array that contains the substrings in this instance that are delimited by elements of a specified string or Unicode character array.

Přetížení

Split(Char[], Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě znaků v poli.Splits a string into a maximum number of substrings based on the characters in an array.

Split(Char, Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě poskytnutého oddělovače znaků.Splits a string into a maximum number substrings based on the provided character separator.

Split(String[], Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě řetězců v poli.Splits a string into a maximum number of substrings based on the strings in an array. Můžete určit, zda podřetězce obsahují prázdné prvky pole.You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions)

Rozdělí řetězec na podřetězce na základě řetězců v poli.Splits a string into substrings based on the strings in an array. Můžete určit, zda podřetězce obsahují prázdné prvky pole.You can specify whether the substrings include empty array elements.

Split(String, Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaného oddělovače řetězce.Splits a string into a maximum number of substrings based on the provided string separator.

Split(Char[], StringSplitOptions)

Rozdělí řetězec na podřetězce na základě znaků v poli.Splits a string into substrings based on the characters in an array. Můžete určit, zda podřetězce obsahují prázdné prvky pole.You can specify whether the substrings include empty array elements.

Split(Char[], Int32)

Rozdělí řetězec na maximální počet podřetězců na základě znaků v poli.Splits a string into a maximum number of substrings based on the characters in an array. Zadejte také maximální počet podřetězců, které se mají vrátit.You also specify the maximum number of substrings to return.

Split(Char, StringSplitOptions)

Rozdělí řetězec na podřetězce na základě poskytnutého oddělovače znaků.Splits a string into substrings based on the provided character separator.

Split(String, StringSplitOptions)

Rozdělí řetězec na podřetězce, které jsou založeny na zadaném oddělovači řetězců.Splits a string into substrings that are based on the provided string separator.

Split(Char[])

Rozdělí řetězec na podřetězce, které jsou založeny na znacích pole oddělovače.Splits a string into substrings that are based on the characters in the separator array.

Poznámky

Split slouží k rozdělení řetězce s oddělovači do podřetězců.Split is used to break a delimited string into substrings. Můžete použít buď pole znaků, chcete-li určit nula, jeden nebo více znaků oddělovače (Split(Char[]) metoda), nebo můžete použít pole znaků k určení nulového, jednoho nebo více řetězců s oddělovači.You can use either a character array to specify zero, one, or multiple delimiting characters (the Split(Char[]) method), or you can use a character array to specify zero, one, or multiple delimiting strings. Přetížení metody Split umožňují omezit počet podřetězců vrácených metodou (metoda Split(Char[], Int32)) k určení, zda jsou prázdné řetězce zahrnuty do vrácených podřetězců (metody Split(Char[], StringSplitOptions) a Split(String[], StringSplitOptions), nebo pro obojí (Split(Char[], Int32, StringSplitOptions) a Split(String[], Int32, StringSplitOptions) metody).Overloads of the Split method allow you to limit the number of substrings returned by the method (the Split(Char[], Int32) method), to determine whether empty strings are included in the returned substrings (the Split(Char[], StringSplitOptions) and Split(String[], StringSplitOptions) methods, or to do both (the Split(Char[], Int32, StringSplitOptions) and Split(String[], Int32, StringSplitOptions) methods).

Poznámka

Ukázky C#, v tomto článku spusťte Try.NET runner a playground vloženého kódu.The C# examples in this article run in the Try.NET inline code runner and playground. Vyberte spustit tlačítko spustit příklad v interaktivním okně.Select the Run button to run an example in an interactive window. Jakmile se při spuštění kódu, můžete upravit a spustit upravený kód tak, že vyberete spustit znovu.Once you execute the code, you can modify it and run the modified code by selecting Run again. Upravené kód je buď spuštěn v interaktivním okně, nebo pokud kompilace se nezdaří, interaktivní okno zobrazuje všechny jazyka C# kompilátoru chybové zprávy.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Alternativy k řetězci. SplitAlternatives to String.Split

Metoda Split není vždy nejlepším způsobem, jak rozdělit oddělený řetězec do podřetězců.The Split method is not always the best way to break a delimited string into substrings. Pokud nechcete extrahovat všechny podřetězce v řetězci s oddělovači, nebo pokud chcete analyzovat řetězec na základě vzoru namísto množiny znaků oddělovače, zvažte následující alternativy.If you don't want to extract all of the substrings of a delimited string, or if you want to parse a string based on a pattern instead of a set of delimiter characters, consider the following alternatives.

Regulární výrazyRegular expressions

Pokud jsou řetězce v souladu s pevným vzorem, můžete použít regulární výraz pro extrakci a zpracování jejich prvků.If your strings conform to a fixed pattern, you can use a regular expression to extract and handle their elements. Například pokud řetězce mají podobu "číslo operandu ", můžete použít regulární výraz pro extrakci a zpracování elementů řetězce.For example, if strings take the form "number operand number" you can use a regular expression to extract and handle the string's elements. Tady je příklad:Here's an example:

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

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

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

Vzor regulárního výrazu (\d+)\s+([-+*/])\s+(\d+) je definován takto:The regular expression pattern (\d+)\s+([-+*/])\s+(\d+) is defined like this:

VzorPattern PopisDescription
(\d+) Porovná jednu nebo více desítkových číslic.Match one or more decimal digits. Toto je první zachytávající skupina.This is the first capturing group.
\s+ Porovnává jeden nebo více prázdných znaků.Match one or more white-space characters.
([-+*/]) Porovná znaménko aritmetického operátoru (+,-, * nebo/).Match an arithmetic operator sign (+, -, *, or /). Toto je druhá zachytávající skupina.This is the second capturing group.
\s+ Porovnává jeden nebo více prázdných znaků.Match one or more white-space characters.
(\d+) Porovná jednu nebo více desítkových číslic.Match one or more decimal digits. Toto je třetí zachytávající skupina.This is the third capturing group.

Můžete také použít regulární výraz pro extrakci podřetězců z řetězce založeného na vzoru, nikoli v pevně dané sadě znaků.You can also use a regular expression to extract substrings from a string based on a pattern rather than a fixed set of characters. Toto je běžný scénář, pokud dojde k některé z těchto podmínek:This is a common scenario when either of these conditions occurs:

  • Jeden nebo více znaků oddělovače nikdy neslouží jako oddělovač v instanci String.One or more of the delimiter characters does not always serve as a delimiter in the String instance.

  • Sekvence a počet znaků oddělovače jsou proměnné nebo neznámé.The sequence and number of delimiter characters is variable or unknown.

Například metodu Split nelze použít k rozdělení následujícího řetězce, protože počet \n (in C#) nebovbCrLf(v Visual Basic) znaků je proměnná a neslouží vždy jako oddělovače.For example, the Split method cannot be used to split the following string, because the number of \n (in C#) or vbCrLf (in Visual Basic) characters is variable, and they don't always serve as delimiters.

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

Regulární výraz může tento řetězec snadno rozdělit, jak ukazuje následující příklad.A regular expression can split this string easily, as the following example shows.

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

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

Vzor regulárního výrazu \[([^\[\]]+)\] je definován takto:The regular expression pattern \[([^\[\]]+)\] is defined like this:

VzorPattern PopisDescription
\[ Porovnává levou hranatou závorku.Match an opening bracket.
([^\[\]]+) Odpovídá jakémukoli znaku, který není levou nebo pravou hranatou závorkou jednou nebo vícekrát.Match any character that is not an opening or a closing bracket one or more times. Toto je první zachytávající skupina.This is the first capturing group.
\] Porovnává pravou závorku.Match a closing bracket.

Metoda Regex.Split je téměř totožná s String.Split, s tím rozdílem, že rozdělí řetězec na základě vzoru regulárního výrazu namísto pevné znakové sady.The Regex.Split method is almost identical to String.Split, except that it splits a string based on a regular expression pattern instead of a fixed character set. Například následující příklad používá metodu Regex.Split k rozdělení řetězce, který obsahuje podřetězce oddělené různými kombinacemi spojovníků a dalších znaků.For example, the following example uses the Regex.Split method to split a string that contains substrings delimited by various combinations of hyphens and other characters.

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

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

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

Vzor regulárního výrazu \s-\s?[+*]?\s?-\s je definován takto:The regular expression pattern \s-\s?[+*]?\s?-\s is defined like this:

VzorPattern PopisDescription
\s- Porovnává mezeru za prázdným znakem následovaným spojovníkem.Match a white-space character followed by a hyphen.
\s? Porovná žádný nebo jeden prázdný znak.Match zero or one white-space character.
[+*]? Porovná žádný nebo jeden výskyt znaku + nebo *.Match zero or one occurrence of either the + or * character.
\s? Porovná žádný nebo jeden prázdný znak.Match zero or one white-space character.
-\s Porovnává pomlčku následovanou prázdným znakem.Match a hyphen followed by a white-space character.

Metody hledání a metoda substringSearch methods and the Substring method

Pokud si nejste jisti všemi podřetězci v řetězci, můžete chtít pracovat s jednou z metod porovnání řetězců, které vrátí index, ve kterém je začátek shody.If you aren't interested in all of the substrings in a string, you might prefer to work with one of the string comparison methods that returns the index at which the match begins. Potom můžete zavolat metodu Substring pro extrakci podřetězce, který chcete.You can then call the Substring method to extract the substring that you want. Metody porovnání řetězců zahrnují:The string comparison methods include:

  • IndexOf, která vrací index založený na nule prvního výskytu znaku nebo řetězce v instanci řetězce.IndexOf, which returns the zero-based index of the first occurrence of a character or string in a string instance.

  • IndexOfAny, která vrací index založený na nule v aktuální instanci řetězce prvního výskytu libovolného znaku v poli znaků.IndexOfAny, which returns the zero-based index in the current string instance of the first occurrence of any character in a character array.

  • LastIndexOf, která vrací index založený na nule posledního výskytu znaku nebo řetězce v instanci řetězce.LastIndexOf, which returns the zero-based index of the last occurrence of a character or string in a string instance.

  • LastIndexOfAny, která vrací index založený na nule v aktuální instanci řetězce posledního výskytu libovolného znaku v poli znaků.LastIndexOfAny, which returns a zero-based index in the current string instance of the last occurrence of any character in a character array.

Následující příklad používá metodu IndexOf k nalezení teček v řetězci.The following example uses the IndexOf method to find the periods in a string. Pak pomocí metody Substring vrátí úplné věty.It then uses the Substring method to return full sentences.

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

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

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

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

Split(Char[], Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě znaků v poli.Splits a string into a maximum number of substrings based on the characters in an array.

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

Parametry

separator
Char[]

Pole znaků, které omezuje podřetězce v tomto řetězci, prázdné pole obsahující žádné oddělovače nebo null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32

Maximální počet podřetězců, které se mají vrátit.The maximum number of substrings to return.

options
StringSplitOptions

RemoveEmptyEntries vynechat prázdné prvky pole z vráceného pole; nebo None, aby se do vráceného pole zahrnuly prázdné prvky pole.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

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.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. Další informace najdete v části poznámky.For more information, see the Remarks section.

Atributy

Výjimky

count je negativní.count is negative.

options není jednou z hodnot StringSplitOptions.options is not one of the StringSplitOptions values.

Příklady

Následující příklad používá výčet StringSplitOptions pro zahrnutí nebo vyloučení podřetězců generovaných metodou Split.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

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

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

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

/*
This example produces the following results:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

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

Poznámky

Znaky oddělovače nejsou zahrnuty v prvcích vráceného pole.Delimiter characters are not included in the elements of the returned array.

Pokud tato instance neobsahuje žádný ze znaků v separator nebo je parametrem count 1, vrácený objekt se skládá z jednoho prvku, který obsahuje tuto instanci.If this instance does not contain any of the characters in separator, or the count parameter is 1, the returned array consists of a single element that contains this instance. Pokud je parametr separator null nebo neobsahuje žádné znaky, považují se prázdné znaky za oddělovače.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Prázdné znaky jsou definovány standardem Unicode a vracejí true, pokud jsou předány metodě Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Pokud je však parametr separator v volání této metody přetížení null, řešení přetížení kompilátoru se nezdařilo.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Chcete-li jednoznačně identifikovat volanou metodu, váš kód musí označovat typ hodnoty null.To unambiguously identify the called method, your code must indicate the type of the null. Následující příklad ukazuje několik způsobů k jednoznačné identifikaci tohoto přetížení.The following example shows several ways to unambiguously identify this overload.

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

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

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

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

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

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

Pokud je parametr count nula nebo parametr options je RemoveEmptyEntries a délka této instance je nula, vrátí se prázdné pole.If the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

Každý prvek separator definuje samostatný oddělovač znaků.Each element of separator defines a separate delimiter character. Pokud je parametr options 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 Empty.If the options parameter is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Pokud v této instanci existuje více než count podřetězců, první count minus 1 podřetězce jsou vráceny v prvním count mínus 1 prvky návratové hodnoty a zbývající znaky v této instanci jsou vráceny v posledním elementu návratové hodnoty. .If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

Pokud je count větší než počet podřetězců, jsou vráceny podřetězce, které jsou k dispozici, a není vyvolána žádná výjimka.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Faktory ovlivňující výkonPerformance Considerations

Metody Split přidělují paměť pro vrácený objekt Array a objekt String pro každý prvek pole.The Split methods allocate memory for the returned array object and a String object for each array element. 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í metody IndexOf nebo IndexOfAny a volitelně také metody Compare k vyhledání podřetězce v rámci řetězce.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Pokud je řetězec rozdělen znakem oddělovače, použijte metodu IndexOf nebo IndexOfAny k vyhledání znaku oddělovače v řetězci.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Pokud je řetězec rozdělen do oddělovače, použijte metodu IndexOf nebo IndexOfAny k vyhledání prvního znaku oddělovače řetězce.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Pak použijte metodu Compare k určení, zda znaky za tímto prvním znakem jsou rovny zbývajícím znakům řetězce oddělovače.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Kromě toho, pokud je použita stejná sada znaků k rozdělení řetězců ve více voláních metody Split, zvažte vytvoření jednoho pole a odkazování na něj v každém volání metody.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. To významně snižuje režii dalšího volání metody.This significantly reduces the additional overhead of each method call.

Poznámky pro volající

V .NET Framework 3.5.NET Framework 3.5 a starších verzích, pokud je metoda Split(Char[]) předána separator, která je null nebo neobsahuje žádné znaky, metoda používá mírně odlišnou sadu znaků pro rozdělení řetězce, než Trim(Char[]) metoda provede oříznutí řetězce.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. Počínaje .NET Framework 4 obě metody používají stejnou sadu prázdných znaků Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char, Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě poskytnutého oddělovače znaků.Splits a string into a maximum number substrings based on the provided character separator.

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

Parametry

separator
Char

Znak, který odděluje podřetězce v této instanci.A character that delimits the substrings in this instance.

count
Int32

Maximální počet prvků očekávaný v poli.The maximum number of elements expected in the array.

options
StringSplitOptions

Jedna z hodnot výčtu, která určuje, zda má operace rozdělení vynechat prázdné podřetězce z návratové hodnoty.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Návraty

String[]

Pole, jehož prvky obsahují nejvíce count podřetězců z této instance, které jsou odděleny separator.An array whose elements contain at most count substrings from this instance that are delimited by separator.

Poznámky

Pokud byl řetězec již rozdělen count-1 krát, ale nebyl dosažen konec řetězce, pak poslední řetězec ve vráceném poli bude obsahovat zbývající koncový řetězec této instance, který není změněn.If the string has already been split count - 1 times, but the end of the string has not been reached, then the last string in the returned array will contain this instance's remaining trailing substring, untouched.

Split(String[], Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě řetězců v poli.Splits a string into a maximum number of substrings based on the strings in an array. Můžete určit, zda podřetězce obsahují prázdné prvky pole.You can specify whether the substrings include empty array elements.

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

Parametry

separator
String[]

Pole řetězců, které omezuje podřetězce v tomto řetězci, prázdné pole obsahující žádné oddělovače nebo null.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32

Maximální počet podřetězců, které se mají vrátit.The maximum number of substrings to return.

options
StringSplitOptions

RemoveEmptyEntries vynechat prázdné prvky pole z vráceného pole; nebo None, aby se do vráceného pole zahrnuly prázdné prvky pole.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Návraty

String[]

Pole, jehož prvky obsahují podřetězce v tomto řetězci, které jsou odděleny jedním nebo více řetězci v separator.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. Další informace najdete v části poznámky.For more information, see the Remarks section.

Atributy

Výjimky

count je negativní.count is negative.

options není jednou z hodnot StringSplitOptions.options is not one of the StringSplitOptions values.

Příklady

Následující příklad používá výčet StringSplitOptions pro zahrnutí nebo vyloučení podřetězců generovaných metodou Split.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

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

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

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

/*
This example produces the following results:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

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

Poznámky

Podrobnosti návratové hodnotyReturn value details

Řetězce oddělovače nejsou zahrnuty do prvků vráceného pole.Delimiter strings are not included in the elements of the returned array.

Pokud tato instance neobsahuje žádný z řetězců v separator, nebo je parametrem count 1, vrácený objekt se skládá z jednoho prvku, který obsahuje tuto instanci.If this instance does not contain any of the strings in separator, or the count parameter is 1, the returned array consists of a single element that contains this instance. Pokud je parametr separator null nebo neobsahuje žádné znaky, považují se prázdné znaky za oddělovače.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Prázdné znaky jsou definovány standardem Unicode a vracejí true, pokud jsou předány metodě Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Pokud je však parametr separator v volání této metody přetížení null, řešení přetížení kompilátoru se nezdařilo.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Chcete-li jednoznačně identifikovat volanou metodu, váš kód musí označovat typ null.To unambiguously identify the called method, your code must indicate the type of the null. Následující příklad ukazuje několik způsobů k jednoznačné identifikaci tohoto přetížení.The following example shows several ways to unambiguously identify this overload.

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

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

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

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

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

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

Pokud je parametr count nula nebo parametr options je RemoveEmptyEntries a délka této instance je nula, vrátí se prázdné pole.If the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

Každý prvek separator definuje samostatný oddělovač, který se skládá z jednoho nebo více znaků.Each element of separator defines a separate delimiter that consists of one or more characters. Pokud je parametr options 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 Empty.If the options parameter is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Pokud v této instanci existuje více než count podřetězců, první count minus 1 podřetězce jsou vráceny v prvním count mínus 1 prvky návratové hodnoty a zbývající znaky v této instanci jsou vráceny v posledním elementu návratové hodnoty. .If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

Pokud je count větší než počet podřetězců, jsou vráceny podřetězce, které jsou k dispozici, a není vyvolána žádná výjimka.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Pole oddělovačeThe separator array

Pokud některý z prvků v separator sestává z více znaků, celý podřetězec je považován za oddělovač.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Například pokud jeden z prvků v separator je "10", pokusí se rozdělit řetězec "This10is10a10string".For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." Vrátí toto pole se čtyřmi prvky: {"This", "is", "a", "String".returns this four-element array: { "This", "is", "a", "string." }.}.

Podrobnosti porovnáníComparison details

Metoda Split extrahuje podřetězce v tomto řetězci, které jsou odděleny jedním nebo více řetězci v parametru separator a vrátí tyto podřetězce jako prvky pole.The Split method extracts the substrings in this string that are delimited by one or more of the strings in the separator parameter, and returns those substrings as elements of an array.

Metoda Split hledá oddělovače porovnáním s pravidly pro řazení podle pořadí podle velkých a malých písmen.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Další informace o aplikaci Word, řetězci a pořadí řazení naleznete v System.Globalization.CompareOptions výčtu.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Metoda Split ignoruje všechny prvky separator, jejichž hodnota je null nebo prázdný řetězec ("").The Split method ignores any element of separator whose value is null or the empty string ("").

Aby nedocházelo k nejednoznačným výsledkům, když řetězce v separator mají běžné znaky, metoda Split pokračuje od začátku až do konce hodnoty instance a odpovídá prvnímu prvku v separator, který je roven oddělovači v instanci.To avoid ambiguous results when strings in separator have characters in common, the Split method proceeds from the beginning to the end of the value of the instance, and matches the first element in separator that is equal to a delimiter in the instance. Pořadí, ve kterém se v instanci vyskytují podřetězce, má přednost před pořadím prvků v separator.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Zvažte například instanci, jejíž hodnota je "ABCDEF".For example, consider an instance whose value is "abcdef". Pokud byl první prvek v separator "EF" a druhý prvek byl "bcde", výsledek rozdělené operace by byl "a" a "f".If the first element in separator was "ef" and the second element was "bcde", the result of the split operation would be "a" and "f". Důvodem je, že se zjistil podřetězec v instanci "bcde" a odpovídá prvku v separator před tím, než se narazí na dílčí řetězec "f".This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

Pokud však první prvek separator byl "bcd" a druhý prvek byl "BC", výsledek rozdělené operace by byl "a" a "EF".However, if the first element of separator was "bcd" and the second element was "bc", the result of the split operation would be "a" and "ef". Důvodem je, že "bcd" je první oddělovač v separator, který odpovídá oddělovači v instanci.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Pokud byl pořadí oddělovačů obrácené, takže první prvek byl "BC" a druhý prvek byl "bcd", výsledek by byl "a" a "def".If the order of the separators was reversed so the first element was "bc" and the second element was "bcd", the result would be "a" and "def".

Důležité informace o výkonuPerformance considerations

Metody Split přidělují paměť pro vrácený objekt Array a objekt String pro každý prvek pole.The Split methods allocate memory for the returned array object and a String object for each array element. 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í metody IndexOf nebo IndexOfAny a volitelně také metody Compare k vyhledání podřetězce v rámci řetězce.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Pokud je řetězec rozdělen znakem oddělovače, použijte metodu IndexOf nebo IndexOfAny k vyhledání znaku oddělovače v řetězci.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Pokud je řetězec rozdělen do oddělovače, použijte metodu IndexOf nebo IndexOfAny k vyhledání prvního znaku oddělovače řetězce.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Pak použijte metodu Compare k určení, zda znaky za tímto prvním znakem jsou rovny zbývajícím znakům řetězce oddělovače.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Kromě toho, pokud je použita stejná sada znaků k rozdělení řetězců ve více voláních metody Split, zvažte vytvoření jednoho pole a odkazování na něj v každém volání metody.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. To významně snižuje režii dalšího volání metody.This significantly reduces the additional overhead of each method call.

Poznámky pro volající

V .NET Framework 3.5.NET Framework 3.5 a starších verzích, pokud je metoda Split(Char[]) předána separator, která je null nebo neobsahuje žádné znaky, metoda používá mírně odlišnou sadu znaků pro rozdělení řetězce, než Trim(Char[]) metoda provede oříznutí řetězce.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. Počínaje .NET Framework 4 obě metody používají stejnou sadu prázdných znaků Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(String[], StringSplitOptions)

Rozdělí řetězec na podřetězce na základě řetězců v poli.Splits a string into substrings based on the strings in an array. Můžete určit, zda podřetězce obsahují prázdné prvky pole.You can specify whether the substrings include empty array elements.

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

Parametry

separator
String[]

Pole řetězců, které omezuje podřetězce v tomto řetězci, prázdné pole obsahující žádné oddělovače nebo null.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions

RemoveEmptyEntries vynechat prázdné prvky pole z vráceného pole; nebo None, aby se do vráceného pole zahrnuly prázdné prvky pole.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Návraty

String[]

Pole, jehož prvky obsahují podřetězce v tomto řetězci, které jsou odděleny jedním nebo více řetězci v separator.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. Další informace najdete v části poznámky.For more information, see the Remarks section.

Atributy

Výjimky

options není jednou z hodnot StringSplitOptions.options is not one of the StringSplitOptions values.

Příklady

Následující příklad znázorňuje rozdíl v polích vrácených voláním metody String.Split(String[], StringSplitOptions) řetězce s jeho parametrem options rovno StringSplitOptions.None a StringSplitOptions.RemoveEmptyEntries.The following example illustrates the difference in the arrays returned by calling a string's String.Split(String[], StringSplitOptions) method with its options parameter equal to StringSplitOptions.None and StringSplitOptions.RemoveEmptyEntries.

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

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

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

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

Následující příklad definuje pole oddělovačů, které obsahují interpunkční znaménka a prázdné znaky.The following example defines an array of separators that include punctuation and white-space characters. Předání tohoto pole spolu s hodnotou StringSplitOptions.RemoveEmptyEntries do metody Split(String[], StringSplitOptions) vrátí pole, které se skládá z jednotlivých slov z řetězce.Passing this array along with a value of StringSplitOptions.RemoveEmptyEntries to the Split(String[], StringSplitOptions) method returns an array that consists of the individual words from the string.

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

Všimněte si, že metoda je volána s argumentem options nastaveným na hodnotu StringSplitOptions.RemoveEmptyEntries.Note that the method is called with the options argument set to StringSplitOptions.RemoveEmptyEntries. Tím zabráníte vrácenému poli z zahrnutí String.Empty hodnot, které reprezentují prázdné podřetězce mezi interpunkčními znaménky a prázdnými znaky.This prevents the returned array from including String.Empty values that represent empty substring matches between punctuation marks and white-space characters.

Poznámky

Pokud je řetězec oddělený známou sadou řetězců, můžete použít metodu Split pro oddělení do podřetězců.When a string is delimited by a known set of strings, you can use the Split method to separate it into substrings.

Podrobnosti návratové hodnotyReturn value details

Řetězce oddělovače nejsou zahrnuty do prvků vráceného pole.Delimiter strings are not included in the elements of the returned array. Například pokud pole separator obsahuje řetězec "--" a hodnotu aktuální instance řetězce je "AA--BB-CC", metoda vrátí pole, které obsahuje tři prvky: "AA", "BB" a "CC".For example, if the separator array includes the string "--" and the value of the current string instance is "aa--bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

Pokud tato instance neobsahuje žádný z řetězců v separator, vrácené pole se skládá z jednoho prvku, který obsahuje tuto instanci.If this instance does not contain any of the strings in separator, the returned array consists of a single element that contains this instance.

Pokud je parametr options RemoveEmptyEntries a délka této instance je nula, metoda vrátí prázdné pole.If the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

Každý prvek separator definuje samostatný oddělovač, který se skládá z jednoho nebo více znaků.Each element of separator defines a separate delimiter that consists of one or more characters. Pokud je argument options 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.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. Například pokud separator obsahuje dva prvky, "-" a "_", hodnota instance řetězce je "-_AA-_" a hodnota argumentu options je None, metoda vrátí pole Sting s pěti prvky. :For example, if separator includes two elements, "-" and "_", the value of the string instance is "-_aa-_", and the value of the options argument is None, the method returns a sting array with the following five elements:

  1. String.Empty, která představuje prázdný řetězec, který předchází řetězci "-" na indexu 0.String.Empty, which represents the empty string that precedes the "-" substring at index 0.

  2. String.Empty, která představuje prázdný řetězec mezi podřetězcem "-" na indexu 0 a podřetězcem "" na indexu 1.String.Empty, which represents the empty string between the "-" substring at index 0 and the "" substring at index 1.

  3. AA,"aa",

  4. String.Empty, která představuje prázdný řetězec, který následuje po podřetězci "" na indexu 4.String.Empty, which represents the empty string that follows the "" substring at index 4.

  5. String.Empty, která představuje prázdný řetězec, který následuje po řetězci "-" na indexu 5.String.Empty, which represents the empty string that follows the "-" substring at index 5.

Pole oddělovačeThe separator array

Pokud některý z prvků v separator sestává z více znaků, celý podřetězec je považován za oddělovač.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Například pokud jeden z prvků v separator je "10", pokusí se rozdělit řetězec "This10is10a10string".For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." vrátí následující pole se čtyřmi prvky: {"This", "is", "a", "String".returns the following four-element array: { "This", "is", "a", "string." }.}.

Pokud je parametr separator null nebo neobsahuje žádné znaky, považují se prázdné znaky za oddělovače.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Prázdné znaky jsou definovány standardem Unicode a vracejí true, pokud jsou předány metodě Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Pokud je parametr separator v volání této metody přetížení null, řešení přetížení kompilátoru se nezdařilo.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Chcete-li jednoznačně identifikovat volanou metodu, váš kód musí označovat typ null.To unambiguously identify the called method, your code must indicate the type of the null. Následující příklad ukazuje několik způsobů k jednoznačné identifikaci tohoto přetížení.The following example shows several ways to unambiguously identify this overload.

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

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

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

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

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

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

Podrobnosti porovnáníComparison details

Metoda Split extrahuje podřetězce v tomto řetězci, které jsou odděleny jedním nebo více řetězci v parametru separator a vrátí tyto podřetězce jako prvky pole.The Split method extracts the substrings in this string that are delimited by one or more of the strings in the separator parameter, and returns those substrings as elements of an array.

Metoda Split hledá oddělovače porovnáním s pravidly pro řazení podle pořadí podle velkých a malých písmen.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Další informace o aplikaci Word, řetězci a pořadí řazení naleznete v System.Globalization.CompareOptions výčtu.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Metoda Split ignoruje všechny prvky separator, jejichž hodnota je null nebo prázdný řetězec ("").The Split method ignores any element of separator whose value is null or the empty string ("").

Aby nedocházelo k nejednoznačným výsledkům, když řetězce v separator mají běžné znaky, operace Split pokračuje od začátku až do konce hodnoty instance a odpovídá prvnímu prvku v separator, který je roven oddělovači v instanci.To avoid ambiguous results when strings in separator have characters in common, the Split operation proceeds from the beginning to the end of the value of the instance, and matches the first element in separator that is equal to a delimiter in the instance. Pořadí, ve kterém se v instanci vyskytují podřetězce, má přednost před pořadím prvků v separator.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Zvažte například instanci, jejíž hodnota je "ABCDEF".For example, consider an instance whose value is "abcdef". Pokud první prvek v separator byl "EF" a druhý prvek byl "bcde", výsledkem operace rozdělení bude pole řetězců, které obsahuje dva prvky, "a" a "f".If the first element in separator was "ef" and the second element was "bcde", the result of the split operation would be a string array that contains two elements, "a" and "f". Důvodem je, že se zjistil podřetězec v instanci "bcde" a odpovídá prvku v separator před tím, než se narazí na dílčí řetězec "f".This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

Pokud však první prvek separator byl "bcd" a druhý prvek byl "BC", výsledkem operace rozdělení bude pole řetězců, které obsahuje dva prvky, "a" a "EF".However, if the first element of separator was "bcd" and the second element was "bc", the result of the split operation would be a string array that contains two elements, "a" and "ef". Důvodem je, že "bcd" je první oddělovač v separator, který odpovídá oddělovači v instanci.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Pokud byl pořadí oddělovačů obrácený, takže první prvek byl "BC" a druhý prvek byl "bcd", výsledkem bude pole řetězců, které obsahuje dva prvky, "a" a "def".If the order of the separators was reversed so the first element was "bc" and the second element was "bcd", the result would be a string array that contains two elements, "a" and "def".

Důležité informace o výkonuPerformance considerations

Metody Split přidělují paměť pro vrácený objekt Array a objekt String pro každý prvek pole.The Split methods allocate memory for the returned array object and a String object for each array element. 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í metody IndexOf nebo IndexOfAny a volitelně také metody Compare k vyhledání podřetězce v rámci řetězce.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Pokud je řetězec rozdělen znakem oddělovače, použijte metodu IndexOf nebo IndexOfAny k vyhledání znaku oddělovače v řetězci.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Pokud je řetězec rozdělen do oddělovače, použijte metodu IndexOf nebo IndexOfAny k vyhledání prvního znaku oddělovače řetězce.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Pak použijte metodu Compare k určení, zda znaky za tímto prvním znakem jsou rovny zbývajícím znakům řetězce oddělovače.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Kromě toho, pokud je použita stejná sada znaků k rozdělení řetězců ve více voláních metody Split, zvažte vytvoření jednoho pole a odkazování na něj v každém volání metody.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. To významně snižuje režii dalšího volání metody.This significantly reduces the additional overhead of each method call.

Poznámky pro volající

V .NET Framework 3.5.NET Framework 3.5 a starších verzích, pokud je metoda Split(Char[]) předána separator, která je null nebo neobsahuje žádné znaky, metoda používá mírně odlišnou sadu znaků pro rozdělení řetězce, než Trim(Char[]) metoda provede oříznutí řetězce.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. Počínaje .NET Framework 4 obě metody používají stejnou sadu prázdných znaků Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(String, Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaného oddělovače řetězce.Splits a string into a maximum number of substrings based on the provided string separator.

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

Parametry

separator
String

Řetězec, který odděluje podřetězce v této instanci.A string that delimits the substrings in this instance.

count
Int32

Maximální počet prvků očekávaný v poli.The maximum number of elements expected in the array.

options
StringSplitOptions

Jedna z hodnot výčtu, která určuje, zda má operace rozdělení vynechat prázdné podřetězce z návratové hodnoty.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Návraty

String[]

Pole, jehož prvky obsahují nejvíce count podřetězců z této instance, které jsou odděleny separator.An array whose elements contain at most count substrings from this instance that are delimited by separator.

Poznámky

Pokud byl řetězec již rozdělen count-1 krát, ale nebyl dosažen konec řetězce, pak poslední řetězec ve vráceném poli bude obsahovat zbývající koncový řetězec této instance, který není změněn.If the string has already been split count - 1 times, but the end of the string has not been reached, then the last string in the returned array will contain this instance's remaining trailing substring, untouched.

Split(Char[], StringSplitOptions)

Rozdělí řetězec na podřetězce na základě znaků v poli.Splits a string into substrings based on the characters in an array. Můžete určit, zda podřetězce obsahují prázdné prvky pole.You can specify whether the substrings include empty array elements.

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

Parametry

separator
Char[]

Pole znaků, které omezuje podřetězce v tomto řetězci, prázdné pole obsahující žádné oddělovače nebo null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions

RemoveEmptyEntries vynechat prázdné prvky pole z vráceného pole; nebo None, aby se do vráceného pole zahrnuly prázdné prvky pole.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

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.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. Další informace najdete v části poznámky.For more information, see the Remarks section.

Atributy

Výjimky

options není jednou z hodnot StringSplitOptions.options is not one of the StringSplitOptions values.

Příklady

Následující příklad používá výčet StringSplitOptions pro zahrnutí nebo vyloučení podřetězců generovaných metodou Split.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

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

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

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

/*
This example produces the following results:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

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

Poznámky

Podrobnosti návratové hodnotyReturn value details

Znaky oddělovače (znaky v poli separator) nejsou zahrnuty do prvků vráceného pole.Delimiter characters (the characters in the separator array) are not included in the elements of the returned array. Například pokud pole separator 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".For example, if the separator array includes the character "-" and the value of the current string instance is "aa-bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

Pokud tato instance neobsahuje žádný ze znaků v separator, vrácené pole se skládá z jednoho prvku, který obsahuje tuto instanci.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

Pokud je parametr options RemoveEmptyEntries a délka této instance je nula, metoda vrátí prázdné pole.If the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

Každý prvek separator definuje samostatný oddělovač, který se skládá z jednoho znaku.Each element of separator defines a separate delimiter that consists of a single character. Pokud je argument options 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.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. Například pokud separator obsahuje dva prvky, "-" a "_", hodnota instance řetězce je "-_AA-_" a hodnota argumentu options je None, metoda vrátí pole řetězců s pěti prvky. :For example, if separator includes two elements, "-" and "_", the value of the string instance is "-_aa-_", and the value of the options argument is None, the method returns a string array with the following five elements:

  1. String.Empty, která představuje prázdný řetězec, který předchází znak "-" na indexu 0.String.Empty, which represents the empty string that precedes the "-" character at index 0.

  2. String.Empty, která představuje prázdný řetězec mezi znakem "-" na indexu 0 a znakem "" na indexu 1.String.Empty, which represents the empty string between the "-" character at index 0 and the "" character at index 1.

  3. AA,"aa",

  4. String.Empty, která představuje prázdný řetězec, který následuje znak "" na indexu 4.String.Empty, which represents the empty string that follows the "" character at index 4.

  5. String.Empty, která představuje prázdný řetězec, který následuje znak "-" na indexu 5.String.Empty, which represents the empty string that follows the "-" character at index 5.

Pole oddělovačeThe separator array

Pokud je parametr separator null nebo neobsahuje žádné znaky, považují se prázdné znaky za oddělovače.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Prázdné znaky jsou definovány standardem Unicode a vracejí true, pokud jsou předány metodě Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Pokud je parametr separator v volání této metody přetížení null, řešení přetížení kompilátoru se nezdařilo.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Chcete-li jednoznačně identifikovat volanou metodu, váš kód musí označovat typ null.To unambiguously identify the called method, your code must indicate the type of the null. Následující příklad ukazuje několik způsobů k jednoznačné identifikaci tohoto přetížení.The following example shows several ways to unambiguously identify this overload.

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

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

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

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

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

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

Podrobnosti porovnáníComparison details

Metoda Split extrahuje podřetězce v tomto řetězci, které jsou odděleny jedním nebo více znaky v parametru separator a vrátí tyto podřetězce jako prvky pole.The Split method extracts the substrings in this string that are delimited by one or more of the characters in the separator parameter, and returns those substrings as elements of an array.

Metoda Split hledá oddělovače porovnáním s pravidly pro řazení podle pořadí podle velkých a malých písmen.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Další informace o aplikaci Word, řetězci a pořadí řazení naleznete v System.Globalization.CompareOptions výčtu.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Faktory ovlivňující výkonPerformance Considerations

Metody Split přidělují paměť pro vrácený objekt Array a objekt String pro každý prvek pole.The Split methods allocate memory for the returned array object and a String object for each array element. 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í metody IndexOf nebo IndexOfAny a volitelně také metody Compare k vyhledání podřetězce v rámci řetězce.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Pokud je řetězec rozdělen znakem oddělovače, použijte metodu IndexOf nebo IndexOfAny k vyhledání znaku oddělovače v řetězci.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Pokud je řetězec rozdělen do oddělovače, použijte metodu IndexOf nebo IndexOfAny k vyhledání prvního znaku oddělovače řetězce.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Pak použijte metodu Compare k určení, zda znaky za tímto prvním znakem jsou rovny zbývajícím znakům řetězce oddělovače.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Kromě toho, pokud je použita stejná sada znaků k rozdělení řetězců ve více voláních metody Split, zvažte vytvoření jednoho pole a odkazování na něj v každém volání metody.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. To významně snižuje režii dalšího volání metody.This significantly reduces the additional overhead of each method call.

Poznámky pro volající

V .NET Framework 3.5.NET Framework 3.5 a starších verzích, pokud je metoda Split(Char[]) předána separator, která je null nebo neobsahuje žádné znaky, metoda používá mírně odlišnou sadu znaků pro rozdělení řetězce, než Trim(Char[]) metoda provede oříznutí řetězce.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. Počínaje .NET Framework 4 obě metody používají stejnou sadu prázdných znaků Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char[], Int32)

Rozdělí řetězec na maximální počet podřetězců na základě znaků v poli.Splits a string into a maximum number of substrings based on the characters in an array. Zadejte také maximální počet podřetězců, které se mají vrátit.You also specify the maximum number of substrings to return.

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

Parametry

separator
Char[]

Pole znaků, které omezuje podřetězce v tomto řetězci, prázdné pole obsahující žádné oddělovače nebo null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32

Maximální počet podřetězců, které se mají vrátit.The maximum number of substrings to return.

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.An array whose elements contain the substrings in this instance that are delimited by one or more characters in separator. Další informace najdete v části poznámky.For more information, see the Remarks section.

Výjimky

count je negativní.count is negative.

Příklady

Následující příklad ukazuje, jak count ovlivňuje počet řetězců vrácených Split.The following example demonstrates how count affects the number of strings returned by Split.

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

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

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

Poznámky

Znaky oddělovače nejsou zahrnuty v prvcích vráceného pole.Delimiter characters are not included in the elements of the returned array.

Pokud tato instance neobsahuje žádný ze znaků v separator, vrácené pole se skládá z jednoho prvku, který obsahuje tuto instanci.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance. Pokud je count nula, vrátí se prázdné pole.If count is zero, an empty array is returned.

Pokud je parametr separator null nebo neobsahuje žádné znaky, považují se prázdné znaky za oddělovače.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Prázdné znaky jsou definovány standardem Unicode a vracejí true, pokud jsou předány metodě Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Každý prvek separator definuje samostatný oddělovač znaků.Each element of separator defines a separate delimiter character. Jsou-li dva oddělovače sousední nebo je-li na začátku nebo konci této instance nalezen oddělovač, obsahuje odpovídající prvek pole Empty.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Pokud v této instanci existuje více než count podřetězců, první count minus 1 podřetězce jsou vráceny v prvním count mínus 1 prvky návratové hodnoty a zbývající znaky v této instanci jsou vráceny v posledním elementu návratové hodnoty. .If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

Pokud je count větší než počet podřetězců, jsou vráceny podřetězce, které jsou k dispozici, a není vyvolána žádná výjimka.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Příklady jsou uvedeny v následující tabulce.The following table provides examples.

Řetězcová hodnotaString value OddělovačSeparator VýpočtuCount Vrácené poleReturned array
"42, 12, 19""42, 12, 19" New Char [] {', ', ' '} (C#)new Char[] {',', ' '} (C#)

Char () = {"," c, "" c} (Visual Basic)Char() = {","c, " "c} (Visual Basic)
odst2 {"42", "12, 19"}{"42", " 12, 19"}
"42.. 12.. 19""42..12..19" nový znak [] {'. '}new Char[] {'.'} (C#)(C#)

Char() = {"."c} (Visual Basic)Char() = {"."c} (Visual Basic)
44 {"42", "", "12", ". 19"}{"42", "", "12", ".19"}
Banán"Banana" nový znak [] {'. '}new Char[] {'.'} (C#)(C#)

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

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

Char () = {} (Visual Basic)Char() = {} (Visual Basic)
první1 {"Darb\nSmarba"} (C#){"Darb\nSmarba"} (C#)

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

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

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

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

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

Faktory ovlivňující výkonPerformance Considerations

Metody Split přidělují paměť pro vrácený objekt Array a objekt String pro každý prvek pole.The Split methods allocate memory for the returned array object and a String object for each array element. 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í metody IndexOf nebo IndexOfAny a volitelně také metody Compare k vyhledání podřetězce v rámci řetězce.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Pokud je řetězec rozdělen znakem oddělovače, použijte metodu IndexOf nebo IndexOfAny k vyhledání znaku oddělovače v řetězci.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Pokud je řetězec rozdělen do oddělovače, použijte metodu IndexOf nebo IndexOfAny k vyhledání prvního znaku oddělovače řetězce.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Pak použijte metodu Compare k určení, zda znaky za tímto prvním znakem jsou rovny zbývajícím znakům řetězce oddělovače.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Kromě toho, pokud je použita stejná sada znaků k rozdělení řetězců ve více voláních metody Split, zvažte vytvoření jednoho pole a odkazování na něj v každém volání metody.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. To významně snižuje režii dalšího volání metody.This significantly reduces the additional overhead of each method call.

Poznámky pro volající

V .NET Framework 3.5.NET Framework 3.5 a starších verzích, pokud je metoda Split(Char[]) předána separator, která je null nebo neobsahuje žádné znaky, metoda používá mírně odlišnou sadu znaků pro rozdělení řetězce, než Trim(Char[]) metoda provede oříznutí řetězce.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. Počínaje .NET Framework 4 obě metody používají stejnou sadu prázdných znaků Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Viz také

Split(Char, StringSplitOptions)

Rozdělí řetězec na podřetězce na základě poskytnutého oddělovače znaků.Splits a string into substrings based on the provided character separator.

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

Parametry

separator
Char

Znak, který odděluje podřetězce v tomto řetězci.A character that delimits the substrings in this string.

options
StringSplitOptions

Jedna z hodnot výčtu, která určuje, zda má operace rozdělení vynechat prázdné podřetězce z návratové hodnoty.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Návraty

String[]

Pole, jehož prvky obsahují podřetězce z této instance, které jsou odděleny separator.An array whose elements contain the substrings from this instance that are delimited by separator.

Split(String, StringSplitOptions)

Rozdělí řetězec na podřetězce, které jsou založeny na zadaném oddělovači řetězců.Splits a string into substrings that are based on the provided string separator.

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

Parametry

separator
String

Řetězec, který odděluje podřetězce v tomto řetězci.A string that delimits the substrings in this string.

options
StringSplitOptions

Jedna z hodnot výčtu, která určuje, zda má operace rozdělení vynechat prázdné podřetězce z návratové hodnoty.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Návraty

String[]

Pole, jehož prvky obsahují podřetězce z této instance, které jsou odděleny separator.An array whose elements contain the substrings from this instance that are delimited by separator.

Split(Char[])

Rozdělí řetězec na podřetězce, které jsou založeny na znacích pole oddělovače.Splits a string into substrings that are based on the characters in the separator array.

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

Parametry

separator
Char[]

Pole znaků, které omezuje podřetězce v tomto řetězci, prázdné pole obsahující žádné oddělovače nebo null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or 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.An array whose elements contain the substrings from this instance that are delimited by one or more characters in separator. Další informace najdete v části poznámky.For more information, see the Remarks section.

Příklady

Následující příklad ukazuje, jak extrahovat jednotlivá slova z bloku textu tím, že zpracovává prázdné znaky a interpunkční znaménka jako oddělovače.The following example demonstrates how to extract individual words from a block of text by treating white space and punctuation marks as delimiters. Pole znaků předané parametru separator metody String.Split(Char[]) se skládá z znaku mezery a znaku tabulátoru a společně s některými běžnými symboly interpunkce.The character array passed to the separator parameter of the String.Split(Char[]) method consists of a space character and a tab character, together with some common punctuation symbols.

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

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

foreach (string s in split) 
{

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

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

Poznámky

Pokud je řetězec oddělený známou sadou znaků, můžete použít metodu Split(Char[]) pro oddělení do podřetězců.When a string is delimited by a known set of characters, you can use the Split(Char[]) method to separate it into substrings.

Podrobnosti návratové hodnotyReturn value details

Znaky oddělovače nejsou zahrnuty v prvcích vráceného pole.Delimiter characters are not included in the elements of the returned array. Například pokud pole oddělovače 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".For example, if the separator array includes the character "-" and the value of the current string instance is "aa-bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

Pokud tato instance neobsahuje žádný ze znaků v separator, vrácené pole se skládá z jednoho prvku, který obsahuje tuto instanci.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

Každý prvek separator definuje samostatný oddělovač znaků.Each element of separator defines a separate delimiter character. Jsou-li dva oddělovače sousední nebo je-li na začátku nebo konci této instance nalezen oddělovač, odpovídající prvek v vráceném poli obsahuje Empty.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding element in the returned array contains Empty. Následuje několik příkladů:Here are some examples:

Řetězcová hodnotaString value OddělovačSeparator Vrácené poleReturned array
"42, 12, 19""42, 12, 19" New Char [] {', ', ' '} (C#)new Char[] {',', ' '} (C#)

Char () = {"," c, "" c}) (Visual Basic)Char() = {","c, " "c}) (Visual Basic)
{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
"42.. 12.. 19""42..12..19" nový znak [] {'. '}new Char[] {'.'} (C#)(C#)

Char() = {"."c} (Visual Basic)Char() = {"."c} (Visual Basic)
{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
Banán"Banana" nový znak [] {'. '}new Char[] {'.'} (C#)(C#)

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

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

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

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

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

Pole oddělovačeThe separator array

Každý prvek oddělovače definuje samostatný oddělovač, který se skládá z jednoho znaku.Each element of separator defines a separate delimiter that consists of a single character. Pokud je argument separator null nebo neobsahuje žádné znaky, metoda zpracovává prázdné znaky jako oddělovače.If the separator argument is null or contains no characters, the method treats white-space characters as the delimiters. Prázdné znaky jsou definovány standardem Unicode; Vrátí true, pokud jsou předány metodě Char.IsWhiteSpace.White-space characters are defined by the Unicode standard; they return true if they are passed to the Char.IsWhiteSpace method.

String. Split (Char []) a rozlišení přetížení kompilátoruString.Split(Char[]) and compiler overload resolution

I když je jediný parametr pro toto přetížení String.Split pole znaků, můžete ho zavolat jediným znakem, jak ukazuje následující příklad.Although the single parameter for this overload of String.Split is a character array, you can call it with a single character, as the following example shows.

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

Vzhledem k tomu, že parametr separator je upraven pomocí atributu ParamArrayAttribute, kompilátor interpretuje jeden znak jako pole znaků s jedním prvkem.Because the separator parameter is decorated with the ParamArrayAttribute attribute, compilers will interpret a single character as a single-element character array. Nejedná se o případ pro jiná String.Split přetížení, která zahrnují separator parametr; je nutné explicitně předat tato přetížení pole znaků jako argument separator.This is not the case for other String.Split overloads that include a separator parameter; you must explicitly pass these overloads a character array as the separator argument.

Podrobnosti porovnáníComparison details

Metoda Split(Char[]) extrahuje podřetězce v tomto řetězci, které jsou odděleny jedním nebo více znaky v poli separator a vrátí tyto podřetězce jako prvky pole.The Split(Char[]) method extracts the substrings in this string that are delimited by one or more of the characters in the separator array, and returns those substrings as elements of an array.

Metoda Split(Char[]) hledá oddělovače porovnáním s pravidly pro řazení podle pořadí podle velkých a malých písmen.The Split(Char[]) method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Další informace o aplikaci Word, řetězci a pořadí řazení naleznete v System.Globalization.CompareOptions výčtu.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Faktory ovlivňující výkonPerformance Considerations

Metody Split přidělují paměť pro vrácený objekt Array a objekt String pro každý prvek pole.The Split methods allocate memory for the returned array object and a String object for each array element. 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í metody IndexOf nebo IndexOfAny.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method. Máte také možnost použít metodu Compare k vyhledání podřetězce v rámci řetězce.You also have the option of using the Compare method to locate a substring within a string.

Chcete-li rozdělit řetězec na oddělovací znak, použijte metodu IndexOf nebo IndexOfAny k vyhledání znaku oddělovače v řetězci.To split a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Chcete-li rozdělit řetězec na oddělovač řetězec, použijte metodu IndexOf nebo IndexOfAny k vyhledání prvního znaku oddělovače řetězce.To split a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Pak použijte metodu Compare k určení, zda znaky za tímto prvním znakem jsou rovny zbývajícím znakům řetězce oddělovače.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Kromě toho, pokud je použita stejná sada znaků k rozdělení řetězců ve více voláních metody Split, zvažte vytvoření jednoho pole a odkazování na něj v každém volání metody.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. To významně snižuje režii dalšího volání metody.This significantly reduces the additional overhead of each method call.

Poznámky pro volající

V .NET Framework 3.5.NET Framework 3.5 a starších verzích, pokud je metoda Split(Char[]) předána separator, která je null nebo neobsahuje žádné znaky, metoda používá mírně odlišnou sadu znaků pro rozdělení řetězce, než Trim(Char[]) metoda provede oříznutí řetězce.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. Počínaje .NET Framework 4 obě metody používají stejnou sadu prázdných znaků Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Viz také

Platí pro