String.Split Método

Definición

Devuelve una matriz de cadenas que contiene las subcadenas de esta instancia que están delimitadas por elementos de la matriz de cadenas o caracteres Unicode especificada.

Sobrecargas

Split(Char[])

Divide una cadena en subcadenas en función de los caracteres de delimitación especificados.

Split(Char, StringSplitOptions)

Divide una cadena en subcadenas en función de un carácter de delimitación especificado y, opcionalmente, las opciones especificadas.

Split(Char[], Int32)

Divide una cadena en un número máximo de subcadenas en función de los caracteres de delimitación especificados.

Split(Char[], StringSplitOptions)

Divide una cadena en subcadenas en función de las opciones y los caracteres de delimitación especificados.

Split(String, StringSplitOptions)

Divide una cadena en subcadenas que se basan en el separador de cadena proporcionado.

Split(String[], StringSplitOptions)

Divide una cadena en subcadenas en función de una cadena de delimitación especificada y, opcionalmente, las opciones especificadas.

Split(Char, Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de un carácter de delimitación especificado y, opcionalmente, las opciones especificadas. Divide una cadena en un número máximo de subcadenas en función del separador de caracteres proporcionado y ofrece la opción de omitir las subcadenas vacías del resultado.

Split(Char[], Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de los caracteres de delimitación especificados y, opcionalmente, las opciones especificadas.

Split(String, Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de una cadena de delimitación especificada y, opcionalmente, las opciones especificadas.

Split(String[], Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de las cadenas de delimitación especificadas y, opcionalmente, las opciones especificadas.

Comentarios

Split se usa para dividir una cadena delimitada en subcadenas. Puede usar una matriz de caracteres o una matriz de cadenas para especificar cero o más caracteres o cadenas delimitadores. Si no se especifica ningún carácter delimitador, la cadena se divide en caracteres de espacio en blanco.

Las sobrecargas del Split método permiten limitar el número de subcadenas devueltas por el método (el Split(Char[], Int32) método ), para especificar si se deben incluir cadenas vacías o subcadenas de recorte en el resultado (los métodos ySplit(String[], StringSplitOptions)) o para hacerlo (los Split(Char[], StringSplitOptions)Split(Char[], Int32, StringSplitOptions) métodos y Split(String[], Int32, StringSplitOptions) ).

Sugerencia

El Split método no siempre es la mejor manera de dividir una cadena delimitada en subcadenas. Si no desea extraer todas las subcadenas de una cadena delimitada, o si desea analizar una cadena basada en un patrón en lugar de un conjunto de caracteres delimitadores, considere la posibilidad de usar expresiones regulares o combinar uno de los métodos de búsqueda que devuelven el índice de un carácter con el Substring método . Para obtener más información, consulte Extracción de subcadenas de una cadena.

Ejemplo

En los siguientes ejemplos se muestran tres sobrecargas diferentes de String.Split(). En el primer ejemplo se llama a la Split(Char[]) sobrecarga y se pasa un único delimitador.

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

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

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

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some.
// Substring: You
// Substring: lose
// Substring: some.
let s = "You win some. You lose some."

let subs = s.Split ' '

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

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

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

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

Como puede ver, los caracteres de punto (.) se incluyen en dos de las subcadenas. Si desea excluir los caracteres de punto, puede agregar el carácter de punto como un carácter delimitador adicional. En el ejemplo siguiente se muestra cómo hacerlo.

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

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

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

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring:
// Substring: You
// Substring: lose
// Substring: some
// Substring:
let s = "You win some. You lose some."

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

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

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

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

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

Los puntos desaparecen de las subcadenas, pero ahora se han incluido dos subcadenas vacías adicionales. Estas subcadenas vacías representan la subcadena entre una palabra y el punto que le sigue. Para omitir las subcadenas vacías de la matriz resultante, puede llamar a la sobrecarga Split(Char[], StringSplitOptions) y especificar StringSplitOptions.RemoveEmptyEntries para el parámetro options.

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

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

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

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring: You
// Substring: lose
// Substring: some
let s = "You win some. You lose some."
let separators = [| ' '; '.' |]

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

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

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

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

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

Las secciones de las sobrecargas individuales de String.Split() contienen ejemplos adicionales.

Split(Char[])

Divide una cadena en subcadenas en función de los caracteres de delimitación especificados.

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

Parámetros

separator
Char[]

Matriz de caracteres de delimitación, matriz vacía sin ningún delimitador o null.

Devoluciones

String[]

Una matriz cuyos elementos contienen las subcadenas de esta instancia que están delimitadas por uno o varios caracteres de separator. Para obtener más información, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se muestra cómo extraer palabras individuales de un bloque de texto tratando el carácter de espacio ( ) y el carácter de tabulación (\t) como delimitadores. La cadena que se divide incluye ambos caracteres.

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

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

// This example produces the following output:
//
// Substring: Today
// Substring: I'm
// Substring: going
// Substring: to
// Substring: school
let s = "Today\tI'm going to school"
let subs = s.Split(' ', '\t')

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

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

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

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

Comentarios

Cuando un conjunto de caracteres conocido delimita una cadena, puede usar el Split(Char[]) método para separarla en subcadenas.

Los caracteres delimitadores no se incluyen en los elementos de la matriz devuelta. Por ejemplo, si la matriz de separadores incluye el carácter "-" y el valor de la instancia de cadena actual es "aa-bb-cc", el método devuelve una matriz que contiene tres elementos: "aa", "bb" y "cc".

Si esta instancia no contiene ninguno de los caracteres de separator, la matriz devuelta consta de un único elemento que contiene esta instancia.

Cada elemento de separator define un carácter delimitador independiente. Si dos delimitadores son adyacentes o se encuentra un delimitador al principio o al final de esta instancia, el elemento correspondiente de la matriz devuelta contiene Empty.

En la tabla siguiente se proporcionan algunos ejemplos.

Idioma Valor de cadena Separador Matriz devuelta
C# "42, 12, 19" new Char[] {',', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char() = {","c, " "c}) {"42", "", "12", "", "19"}
C# "42..12..19." new Char[] {'.'} {"42", "", "12", "", "19", ""}
Visual Basic "42..12..19." Char() = {"." c} {"42", "", "12", "", "19", ""}
C# "Banana" new Char[] {'.'} {"Banana"}
Visual Basic "Banana" Char() = {"." c} {"Banana"}
C# "Darb\nSmarba" new Char[] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char() = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" null {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nada {"Darb", "Smarba"}

Matriz de separadores

Cada elemento del separador define un delimitador independiente que consta de un solo carácter.

Si el separator argumento es null o no contiene caracteres, el método trata los caracteres de espacio en blanco como delimitadores. Los caracteres de espacio en blanco se definen mediante el estándar Unicode y el Char.IsWhiteSpace método devuelve true si se le pasa un carácter de espacio en blanco.

String.Split(Char[]) y resolución de sobrecarga del compilador

Aunque el único parámetro para esta sobrecarga de es una matriz de String.Split caracteres, puede llamarlo con un solo carácter, como se muestra en el ejemplo siguiente.

string value = "This is a short string.";
char delimiter = 's';
string[] substrings = value.Split(delimiter);
foreach (var substring in substrings)
    Console.WriteLine(substring);

// The example displays the following output:
//     Thi
//      i
//      a
//     hort
//     tring.
let value = "This is a short string."
let delimiter = 's'
let substrings = value.Split delimiter
for substring in substrings do
    printfn $"{substring}"

// The example displays the following output:
//     Thi
//      i
//      a
//     hort
//     tring.
    Dim value As String = "This is a short string."
    Dim delimiter As Char = "s"c
    Dim substrings() As String = value.Split(delimiter)
    For Each substring In substrings
        Console.WriteLine(substring)
    Next
End Sub

' The example displays the following output:
'
'     Thi
'      i
'      a
'     hort
'     tring.

Dado que el separator parámetro está decorado con el ParamArrayAttribute atributo , los compiladores interpretarán un solo carácter como una matriz de caracteres de un solo elemento. Este no es el caso de otras String.Split sobrecargas que incluyen un separator parámetro; debe pasar explícitamente estas sobrecargas una matriz de caracteres como separator argumento.

Detalles de comparación

El Split(Char[]) método extrae las subcadenas de esta cadena delimitadas por uno o varios de los caracteres de la separator matriz y devuelve esas subcadenas como elementos de una matriz.

El Split(Char[]) método busca delimitadores realizando comparaciones mediante reglas de ordenación ordinal que distinguen mayúsculas de minúsculas. Para obtener más información sobre las ordenación de palabras, cadenas y ordinales, vea la System.Globalization.CompareOptions enumeración .

Consideraciones sobre el rendimiento

Los Split métodos asignan memoria para el objeto de matriz devuelto y un String objeto para cada elemento de matriz. Si la aplicación requiere un rendimiento óptimo o si la administración de la asignación de memoria es fundamental en la aplicación, considere la posibilidad de usar el IndexOf método o IndexOfAny . También tiene la opción de usar el Compare método para buscar una subcadena dentro de una cadena.

Para dividir una cadena en un carácter separador, use el IndexOf método o IndexOfAny para buscar un carácter separador en la cadena. Para dividir una cadena en una cadena separadora, use el IndexOf método o IndexOfAny para buscar el primer carácter de la cadena separadora. A continuación, use el Compare método para determinar si los caracteres después de ese primer carácter son iguales a los caracteres restantes de la cadena separadora.

Además, si se usa el mismo conjunto de caracteres para dividir cadenas en varias Split llamadas de método, considere la posibilidad de crear una sola matriz y hacer referencia a ella en cada llamada de método. Esto reduce significativamente la sobrecarga adicional de cada llamada de método.

Notas a los autores de las llamadas

En .NET Framework 3.5 y versiones anteriores, si el Split(Char[]) método se pasa o separatornull no contiene caracteres, el método usa un conjunto ligeramente diferente de caracteres de espacio en blanco para dividir la cadena que el Trim(Char[]) método para recortar la cadena. A partir de .NET Framework 4, ambos métodos usan un conjunto idéntico de caracteres de espacio en blanco Unicode.

Consulte también

Se aplica a

Split(Char, StringSplitOptions)

Divide una cadena en subcadenas en función de un carácter de delimitación especificado y, opcionalmente, las opciones especificadas.

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

Parámetros

separator
Char

Un carácter que delimita las subcadenas de esta cadena.

options
StringSplitOptions

Combinación bit a bit de los valores de enumeración que especifica si se deben recortar subcadenas e incluir subcadenas vacías.

Devoluciones

String[]

Una matriz cuyos elementos contienen las subcadenas de esta instancia que están delimitadas por separator.

Se aplica a

Split(Char[], Int32)

Divide una cadena en un número máximo de subcadenas en función de los caracteres de delimitación especificados.

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

Parámetros

separator
Char[]

Matriz de caracteres que delimitan las subcadenas de esta cadena, una matriz vacía sin delimitadores o null.

count
Int32

Número máximo de subcadenas que se van devolver.

Devoluciones

String[]

Una matriz cuyos elementos contienen las subcadenas de esta instancia que están delimitadas por uno o varios caracteres de separator. Para obtener más información, vea la sección Comentarios.

Excepciones

count es negativo.

Ejemplos

En el ejemplo siguiente se muestra cómo count se puede usar para limitar el número de cadenas devueltas por Split.

string name = "Alex Johnson III";

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

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

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

let subs = name.Split(null, 2)

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

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

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

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

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

Comentarios

Los caracteres delimitadores no se incluyen en los elementos de la matriz devuelta.

Si esta instancia no contiene ninguno de los caracteres de separator, la matriz devuelta consta de un único elemento que contiene esta instancia. Si count es cero, se devuelve una matriz vacía.

Si el separator parámetro es null o no contiene caracteres, se supone que los caracteres de espacio en blanco son los delimitadores. Los caracteres de espacio en blanco se definen mediante el estándar Unicode y el Char.IsWhiteSpace método devuelve true si se pasan a él.

Cada elemento de separator define un carácter delimitador independiente. Si dos delimitadores son adyacentes o se encuentra un delimitador al principio o al final de esta instancia, el elemento de matriz correspondiente contiene Empty.

Si hay más de count subcadenas en esta instancia, las primeras count - 1 subcadenas se devuelven en los primeros count - 1 elementos del valor devuelto y los caracteres restantes de esta instancia se devuelven en el último elemento del valor devuelto.

Si count es mayor que el número de subcadenas, se devuelven las subcadenas disponibles y no se produce ninguna excepción.

En la tabla siguiente se proporcionan algunos ejemplos.

Idioma Valor de cadena Separador Matriz devuelta
C# "42, 12, 19" new Char[] {',', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char() = {","c, " "c}) {"42", "", "12", "", "19"}
C# "42..12..19." new Char[] {'.'} {"42", "", "12", "", "19", ""}
Visual Basic "42..12..19." Char() = {"." c} {"42", "", "12", "", "19", ""}
C# "Banana" new Char[] {'.'} {"Banana"}
Visual Basic "Banana" Char() = {"." c} {"Banana"}
C# "Darb\nSmarba" new Char[] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char() = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" null {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nada {"Darb", "Smarba"}

Consideraciones sobre el rendimiento

Los Split métodos asignan memoria para el objeto de matriz devuelto y un String objeto para cada elemento de matriz. Si la aplicación requiere un rendimiento óptimo o si la administración de la asignación de memoria es fundamental en la aplicación, considere la posibilidad de usar el IndexOf método o IndexOfAny y, opcionalmente, el Compare método , para buscar una subcadena dentro de una cadena.

Si va a dividir una cadena en un carácter separador, use el IndexOf método o IndexOfAny para buscar un carácter separador en la cadena. Si va a dividir una cadena en una cadena separadora, use el IndexOf método o IndexOfAny para buscar el primer carácter de la cadena separadora. A continuación, use el Compare método para determinar si los caracteres después de ese primer carácter son iguales a los caracteres restantes de la cadena separadora.

Además, si se usa el mismo conjunto de caracteres para dividir cadenas en varias Split llamadas de método, considere la posibilidad de crear una sola matriz y hacer referencia a ella en cada llamada de método. Esto reduce significativamente la sobrecarga adicional de cada llamada de método.

Notas a los autores de las llamadas

En .NET Framework 3.5 y versiones anteriores, si el Split(Char[]) método se pasa o separatornull no contiene caracteres, el método usa un conjunto ligeramente diferente de caracteres de espacio en blanco para dividir la cadena que el Trim(Char[]) método para recortar la cadena. A partir de .NET Framework 4, ambos métodos usan un conjunto idéntico de caracteres de espacio en blanco Unicode.

Consulte también

Se aplica a

Split(Char[], StringSplitOptions)

Divide una cadena en subcadenas en función de las opciones y los caracteres de delimitación especificados.

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

Parámetros

separator
Char[]

Matriz de caracteres que delimitan las subcadenas de esta cadena, una matriz vacía sin delimitadores o null.

options
StringSplitOptions

Combinación bit a bit de los valores de enumeración que especifica si se deben recortar subcadenas e incluir subcadenas vacías.

Devoluciones

String[]

Una matriz cuyos elementos contienen las subcadenas de esta cadena que están delimitadas por uno o varios caracteres de separator. Para obtener más información, vea la sección Comentarios.

Atributos

Excepciones

options no es uno de los valores de StringSplitOptions.

Ejemplos

En el ejemplo siguiente se usa la StringSplitOptions enumeración para incluir o excluir subcadenas generadas por el Split método .

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

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

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

/*
This example produces the following results:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

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

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

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

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

// Split a string delimited by characters and return all non-empty elements.
printfn "1c) Split a string delimited by characters and return all non-empty elements:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
show result

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

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

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

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

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

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

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

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

(*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*)
    Dim s1 As String = ",ONE,,TWO,,,THREE,,"
    Dim s2 As String = "[stop]" &
                       "ONE[stop][stop]" &
                       "TWO[stop][stop][stop]" &
                       "THREE[stop][stop]"
    Dim charSeparators() As Char = {","c}
    Dim stringSeparators() As String = {"[stop]"}
    Dim result() As String
    ' ------------------------------------------------------------------------------
    ' Split a string delimited by characters.
    ' ------------------------------------------------------------------------------
    Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)

    ' Display the original string and delimiter characters.
    Console.WriteLine("1a) The original string is ""{0}"".", s1)
    Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))

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

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

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

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

    ' ------------------------------------------------------------------------------
    ' Split a string delimited by another string.
    ' ------------------------------------------------------------------------------
    Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)

    ' Display the original string and delimiter string.
    Console.WriteLine("2a) The original string is ""{0}"".", s2)
    Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))

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

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

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

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

End Sub


' Display the array of separated strings.
Public Shared Sub Show(ByVal entries() As String)
    Console.WriteLine("The return value contains these {0} elements:", entries.Length)
    Dim entry As String
    For Each entry In entries
        Console.Write("<{0}>", entry)
    Next entry
    Console.Write(vbCrLf & vbCrLf)

End Sub

'This example produces the following results:
'
'1) Split a string delimited by characters:
'
'1a) The original string is ",ONE,,TWO,,,THREE,,".
'The delimiter character is ','.
'
'1b) Split a string delimited by characters and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'1c) Split a string delimited by characters and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'1d) Split a string delimited by characters and return 2 elements:
'The return value contains these 2 elements:
'<><ONE,,TWO,,,THREE,,>
'
'1e) Split a string delimited by characters and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO,,,THREE,,>
'
'2) Split a string delimited by another string:
'
'2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'The delimiter string is "[stop]".
'
'2b) Split a string delimited by another string and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'2c) Split a string delimited by another string and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'2d) Split a string delimited by another string and return 2 elements:
'The return value contains these 2 elements:
'<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>
'
'2e) Split a string delimited by another string and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO[stop][stop][stop]THREE[stop][stop]>
'

Comentarios

Los caracteres delimitador (los caracteres de la separator matriz) no se incluyen en los elementos de la matriz devuelta. Por ejemplo, si la separator matriz incluye el carácter "-" y el valor de la instancia de cadena actual es "aa-bb-cc", el método devuelve una matriz que contiene tres elementos: "aa", "bb" y "cc".

Si esta instancia no contiene ninguno de los caracteres de separator, la matriz devuelta consta de un único elemento que contiene esta instancia.

Si el options parámetro es RemoveEmptyEntries y la longitud de esta instancia es cero, el método devuelve una matriz vacía.

Cada elemento de separator define un delimitador independiente que consta de un solo carácter. Si el options argumento es Noney dos delimitadores son adyacentes o se encuentra un delimitador al principio o al final de esta instancia, el elemento de matriz correspondiente contiene String.Empty. Por ejemplo, si separator incluye dos elementos y '-''_', el valor de la instancia de cadena es "-_aa-_" y el valor del options argumento es None, el método devuelve una matriz de cadenas con los cinco elementos siguientes:

  1. String.Empty, que representa la cadena vacía que precede al carácter "-" en el índice 0.

  2. String.Empty, que representa la cadena vacía entre el carácter "-" en el índice 0 y el carácter "_" en el índice 1.

  3. "aa".

  4. String.Empty, que representa la cadena vacía que sigue al carácter "-" en el índice 4.

  5. String.Empty, que representa la cadena vacía que sigue al carácter "_" en el índice 5.

Matriz separadora

Si el separator parámetro es null o no contiene caracteres, se supone que los caracteres de espacio en blanco son los delimitadores. Los caracteres de espacio en blanco se definen mediante el estándar Unicode y el Char.IsWhiteSpace método devuelve true si se le pasan.

Para pasar null para el char[] separator parámetro , debe indicar el tipo de para null eliminar la ambigüedad de la llamada de otras sobrecargas, como Split(String[], StringSplitOptions). En el ejemplo siguiente se muestran varias maneras de identificar esta sobrecarga de forma inequívoca.

string phrase = "The quick  brown fox";

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

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

_ = phrase.Split(null as char[], StringSplitOptions.RemoveEmptyEntries);
let phrase = "The quick  brown fox"

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

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

phrase.Split((null: char[]), StringSplitOptions.RemoveEmptyEntries) |> ignore
Dim phrase As String = "The quick brown fox"
Dim words() As String

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

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

Detalles de comparación

El Split método extrae las subcadenas de esta cadena delimitadas por uno o varios de los caracteres del separator parámetro y devuelve esas subcadenas como elementos de una matriz.

El Split método busca delimitadores realizando comparaciones mediante reglas de ordenación ordinal que distinguen mayúsculas de minúsculas. Para obtener más información sobre las ordenación de palabras, cadenas y ordinales, vea la System.Globalization.CompareOptions enumeración .

Consideraciones sobre el rendimiento

Los Split métodos asignan memoria para el objeto de matriz devuelto y un String objeto para cada elemento de matriz. Si la aplicación requiere un rendimiento óptimo o si la administración de la asignación de memoria es fundamental en la aplicación, considere la posibilidad de usar el IndexOf método o IndexOfAny y, opcionalmente, el Compare método , para buscar una subcadena dentro de una cadena.

Si va a dividir una cadena en un carácter separador, use el IndexOf método o IndexOfAny para buscar un carácter separador en la cadena. Si va a dividir una cadena en una cadena separadora, use el IndexOf método o IndexOfAny para buscar el primer carácter de la cadena separadora. A continuación, use el Compare método para determinar si los caracteres posteriores a ese primer carácter son iguales a los caracteres restantes de la cadena separadora.

Además, si se usa el mismo conjunto de caracteres para dividir cadenas en varias Split llamadas de método, considere la posibilidad de crear una sola matriz y hacer referencia a ella en cada llamada al método. Esto reduce significativamente la sobrecarga adicional de cada llamada al método.

Notas a los autores de las llamadas

En .NET Framework 3.5 y versiones anteriores, si el Split(Char[]) método se pasa o separatornull no contiene caracteres, el método usa un conjunto ligeramente diferente de caracteres de espacio en blanco para dividir la cadena que el Trim(Char[]) método para recortar la cadena. A partir de .NET Framework 4, ambos métodos usan un conjunto idéntico de caracteres de espacio en blanco Unicode.

Se aplica a

Split(String, StringSplitOptions)

Divide una cadena en subcadenas que se basan en el separador de cadena proporcionado.

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

Parámetros

separator
String

Una cadena que delimita las subcadenas de esta cadena.

options
StringSplitOptions

Combinación bit a bit de los valores de enumeración que especifica si se deben recortar subcadenas e incluir subcadenas vacías.

Devoluciones

String[]

Una matriz cuyos elementos contienen las subcadenas de esta instancia que están delimitadas por separator.

Se aplica a

Split(String[], StringSplitOptions)

Divide una cadena en subcadenas en función de una cadena de delimitación especificada y, opcionalmente, las opciones especificadas.

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

Parámetros

separator
String[]

Matriz de cadenas que delimitan las subcadenas de esta cadena, una matriz vacía sin delimitadores o null.

options
StringSplitOptions

Combinación bit a bit de los valores de enumeración que especifica si se deben recortar subcadenas e incluir subcadenas vacías.

Devoluciones

String[]

Una matriz cuyos elementos contienen las subcadenas de esta cadena que están delimitadas por una o varias cadenas de separator. Para obtener más información, vea la sección Comentarios.

Atributos

Excepciones

options no es uno de los valores de StringSplitOptions.

Ejemplos

En el ejemplo siguiente se muestra la diferencia en las matrices devueltas mediante una llamada al método de String.Split(String[], StringSplitOptions) una cadena con su options parámetro igual a StringSplitOptions.None y StringSplitOptions.RemoveEmptyEntries.

string source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]";
string[] stringSeparators = new string[] { "[stop]" };
string[] result;

// Display the original string and delimiter string.
Console.WriteLine($"Splitting the string:\n   \"{source}\".");
Console.WriteLine();
Console.WriteLine($"Using the delimiter string:\n   \"{stringSeparators[0]}\"");
Console.WriteLine();

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

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

// The example displays the following output:
//    Splitting the string:
//       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
//    
//    Using the delimiter string:
//       "[stop]"
//    
//    Result including all elements (9 elements):
//       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
//    
//    Result including non-empty elements (3 elements):
//       'ONE' 'TWO' 'THREE'
let source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]"
let stringSeparators = [| "[stop]" |]

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

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

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

// The example displays the following output:
//    Splitting the string:
//       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
//    
//    Using the delimiter string:
//       "[stop]"
//    
//    let result including all elements (9 elements):
//       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
//    
//    let result including non-empty elements (3 elements):
//       'ONE' 'TWO' 'THREE'
Dim source As String = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]"
Dim stringSeparators() As String = {"[stop]"}
Dim result() As String

' Display the original string and delimiter string.
Console.WriteLine("Splitting the string:{0}   '{1}'.", vbCrLf, source)
Console.WriteLine()
Console.WriteLine("Using the delimiter string:{0}   '{1}'.",
                vbCrLf, stringSeparators(0))
Console.WriteLine()

' Split a string delimited by another string and return all elements.
result = source.Split(stringSeparators, StringSplitOptions.None)
Console.WriteLine("Result including all elements ({0} elements):",
                result.Length)
Console.Write("   ")
For Each s As String In result
    Console.Write("'{0}' ", IIf(String.IsNullOrEmpty(s), "<>", s))
Next
Console.WriteLine()
Console.WriteLine()

' Split delimited by another string and return all non-empty elements.
result = source.Split(stringSeparators,
                    StringSplitOptions.RemoveEmptyEntries)
Console.WriteLine("Result including non-empty elements ({0} elements):",
                result.Length)
Console.Write("   ")
For Each s As String In result
    Console.Write("'{0}' ", IIf(String.IsNullOrEmpty(s), "<>", s))
Next
Console.WriteLine()

' The example displays the following output:
'    Splitting the string:
'       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'    
'    Using the delimiter string:
'       "[stop]"
'    
'    Result including all elements (9 elements):
'       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
'    
'    Result including non-empty elements (3 elements):
'       'ONE' 'TWO' 'THREE'

En el ejemplo siguiente se define una matriz de separadores que incluyen signos de puntuación y caracteres de espacio en blanco. Pasar esta matriz junto con un valor de StringSplitOptions.RemoveEmptyEntries al Split(String[], StringSplitOptions) método devuelve una matriz que consta de las palabras individuales de la cadena.

string[] separators = { ",", ".", "!", "?", ";", ":", " " };
string value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";
string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var word in words)
    Console.WriteLine(word);

// The example displays the following output:
//       The
//       handsome
//       energetic
//       young
//       dog
//       was
//       playing
//       with
//       his
//       smaller
//       more
//       lethargic
//       litter
//       mate
let separators = [| ","; "."; "!"; "?"; ""; ":"; " " |]
let value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate."
let words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries)
for word in words do
    printfn $"${word}"

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

' The example displays the following output:
'
'       The
'       handsome
'       energetic
'       young
'       dog
'       was
'       playing
'       with
'       his
'       smaller
'       more
'       lethargic
'       litter
'       mate

Tenga en cuenta que se llama al método con el options argumento establecido StringSplitOptions.RemoveEmptyEntriesen . Esto impide que la matriz devuelta incluya String.Empty valores que representan coincidencias de subcadena vacías entre signos de puntuación y caracteres de espacio en blanco.

Comentarios

Cuando una cadena está delimitada por un conjunto conocido de cadenas, puede usar el Split método para separarla en subcadenas.

Las cadenas delimitadoras no se incluyen en los elementos de la matriz devuelta. Por ejemplo, si la separator matriz incluye la cadena "--" y el valor de la instancia de cadena actual es "aa--bb--cc", el método devuelve una matriz que contiene tres elementos: "aa", "bb" y "cc".

Si esta instancia no contiene ninguna de las cadenas de separator, la matriz devuelta consta de un único elemento que contiene esta instancia.

Si el parámetro es RemoveEmptyEntries y la options longitud de esta instancia es cero, el método devuelve una matriz vacía.

Cada elemento de separator define un delimitador independiente que consta de uno o varios caracteres. Si el options argumento es Noney dos delimitadores son adyacentes o se encuentra un delimitador al principio o al final de esta instancia, el elemento de matriz correspondiente contiene String.Empty. Por ejemplo, si separator incluye dos elementos, "-" y "_", el valor de la instancia de cadena es "-_aa-_" y el valor del options argumento es None, el método devuelve una matriz de cadenas con los cinco elementos siguientes:

  1. String.Empty, que representa la cadena vacía que precede a la subcadena "-" en el índice 0.

  2. String.Empty, que representa la cadena vacía entre la subcadena "-" en el índice 0 y la subcadena "_" en el índice 1.

  3. "aa".

  4. String.Empty, que representa la cadena vacía que sigue a la subcadena "-" en el índice 4.

  5. String.Empty, que representa la cadena vacía que sigue a la subcadena "_" en el índice 5.

Matriz de separadores

Si alguno de los elementos separator de consta de varios caracteres, la subcadena completa se considera un delimitador. Por ejemplo, si uno de los elementos de separator es "10", al intentar dividir la cadena "This10is10a10string". devuelve la siguiente matriz de cuatro elementos: { "This", "is", "a", "string." }.

Si el separator parámetro es null o no contiene cadenas no vacías, se supone que los caracteres de espacio en blanco son los delimitadores. Los caracteres de espacio en blanco se definen mediante el estándar Unicode y el Char.IsWhiteSpace método devuelve true si se le pasan.

Para pasar null para el string[] separator parámetro , debe indicar el tipo de para null eliminar la ambigüedad de la llamada de otras sobrecargas, como Split(Char[], StringSplitOptions). En el ejemplo siguiente se muestran varias maneras de identificar esta sobrecarga de forma inequívoca.

string phrase = "The quick  brown fox";

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

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

_ = phrase.Split(null as string[], StringSplitOptions.RemoveEmptyEntries);
let phrase = "The quick  brown fox"

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

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

phrase.Split((null: string[]), StringSplitOptions.RemoveEmptyEntries) |> ignore
Dim phrase As String = "The quick brown fox"
Dim words() As String

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

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

Detalles de comparación

El Split método extrae las subcadenas de esta cadena delimitadas por una o varias de las cadenas del separator parámetro y devuelve esas subcadenas como elementos de una matriz.

El Split método busca delimitadores realizando comparaciones mediante reglas de ordenación ordinal que distinguen mayúsculas de minúsculas. Para obtener más información sobre las ordenación de palabras, cadenas y ordinales, vea la System.Globalization.CompareOptions enumeración .

El Split método omite cualquier elemento de separator cuyo valor es null o la cadena vacía ("").

Para evitar resultados ambiguos cuando las cadenas de separator tienen caracteres en común, la Split operación continúa desde el principio hasta el final del valor de la instancia y coincide con el primer elemento de separator que es igual a un delimitador de la instancia. El orden en el que se encuentran las subcadenas en la instancia tiene prioridad sobre el orden de los elementos de separator.

Por ejemplo, considere una instancia cuyo valor es "abcdef". Si el primer elemento de separator era "ef" y el segundo elemento era "bcde", el resultado de la operación de división sería una matriz de cadenas que contiene dos elementos, "a" y "f". Esto se debe a que la subcadena de la instancia de , "bcde", se encuentra y coincide con un elemento de separator antes de que se encuentre la subcadena "f".

Sin embargo, si el primer elemento de separator era "bcd" y el segundo elemento era "bc", el resultado de la operación de división sería una matriz de cadenas que contiene dos elementos, "a" y "ef". Esto se debe a que "bcd" es el primer delimitador de separator que coincide con un delimitador en la instancia de . Si el orden de los separadores se revierte para que el primer elemento fuera "bc" y el segundo elemento fuera "bcd", el resultado sería una matriz de cadenas que contiene dos elementos, "a" y "def".

Consideraciones de rendimiento

Los Split métodos asignan memoria para el objeto de matriz devuelto y un String objeto para cada elemento de matriz. Si la aplicación requiere un rendimiento óptimo o si la administración de la asignación de memoria es fundamental en la aplicación, considere la posibilidad de usar el IndexOf método o IndexOfAny y, opcionalmente, el Compare método , para buscar una subcadena dentro de una cadena.

Si va a dividir una cadena en un carácter separador, use el IndexOf método o IndexOfAny para buscar un carácter separador en la cadena. Si va a dividir una cadena en una cadena separadora, use el IndexOf método o IndexOfAny para buscar el primer carácter de la cadena separadora. A continuación, use el Compare método para determinar si los caracteres posteriores a ese primer carácter son iguales a los caracteres restantes de la cadena separadora.

Además, si se usa el mismo conjunto de caracteres para dividir cadenas en varias Split llamadas de método, considere la posibilidad de crear una sola matriz y hacer referencia a ella en cada llamada al método. Esto reduce significativamente la sobrecarga adicional de cada llamada al método.

Notas a los autores de las llamadas

En .NET Framework 3.5 y versiones anteriores, si el Split(Char[]) método se pasa o separatornull no contiene caracteres, el método usa un conjunto ligeramente diferente de caracteres de espacio en blanco para dividir la cadena que el Trim(Char[]) método para recortar la cadena. A partir de .NET Framework 4, ambos métodos usan un conjunto idéntico de caracteres de espacio en blanco Unicode.

Se aplica a

Split(Char, Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de un carácter de delimitación especificado y, opcionalmente, las opciones especificadas. Divide una cadena en un número máximo de subcadenas en función del separador de caracteres proporcionado y ofrece la opción de omitir las subcadenas vacías del resultado.

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

Parámetros

separator
Char

Un carácter que delimita las subcadenas de esta instancia.

count
Int32

El número máximo de elementos que se esperan en la matriz.

options
StringSplitOptions

Combinación bit a bit de los valores de enumeración que especifica si se deben recortar subcadenas e incluir subcadenas vacías.

Devoluciones

String[]

Matriz que contiene como máximo count subcadenas de esta instancia que están delimitadas por separator.

Comentarios

Si la cadena ya se ha dividido count : 1 veces, pero no se ha alcanzado el final de la cadena, la última cadena de la matriz devuelta contendrá la subcadena final restante de esta instancia, sin modificar.

Se aplica a

Split(Char[], Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de los caracteres de delimitación especificados y, opcionalmente, las opciones especificadas.

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

Parámetros

separator
Char[]

Matriz de caracteres que delimitan las subcadenas de esta cadena, una matriz vacía sin delimitadores o null.

count
Int32

Número máximo de subcadenas que se van devolver.

options
StringSplitOptions

Combinación bit a bit de los valores de enumeración que especifica si se deben recortar subcadenas e incluir subcadenas vacías.

Devoluciones

String[]

Matriz que contiene las subcadenas de esta cadena que están delimitadas por uno o varios caracteres de separator. Para obtener más información, vea la sección Comentarios.

Atributos

Excepciones

count es negativo.

options no es uno de los valores de StringSplitOptions.

Ejemplos

En el ejemplo siguiente se usa la StringSplitOptions enumeración para incluir o excluir subcadenas generadas por el Split método .

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

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

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

/*
This example produces the following results:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

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

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

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

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

// Split a string delimited by characters and return all non-empty elements.
printfn "1c) Split a string delimited by characters and return all non-empty elements:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
show result

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

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

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

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

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

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

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

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

(*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*)
    Dim s1 As String = ",ONE,,TWO,,,THREE,,"
    Dim s2 As String = "[stop]" &
                       "ONE[stop][stop]" &
                       "TWO[stop][stop][stop]" &
                       "THREE[stop][stop]"
    Dim charSeparators() As Char = {","c}
    Dim stringSeparators() As String = {"[stop]"}
    Dim result() As String
    ' ------------------------------------------------------------------------------
    ' Split a string delimited by characters.
    ' ------------------------------------------------------------------------------
    Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)

    ' Display the original string and delimiter characters.
    Console.WriteLine("1a) The original string is ""{0}"".", s1)
    Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))

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

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

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

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

    ' ------------------------------------------------------------------------------
    ' Split a string delimited by another string.
    ' ------------------------------------------------------------------------------
    Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)

    ' Display the original string and delimiter string.
    Console.WriteLine("2a) The original string is ""{0}"".", s2)
    Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))

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

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

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

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

End Sub


' Display the array of separated strings.
Public Shared Sub Show(ByVal entries() As String)
    Console.WriteLine("The return value contains these {0} elements:", entries.Length)
    Dim entry As String
    For Each entry In entries
        Console.Write("<{0}>", entry)
    Next entry
    Console.Write(vbCrLf & vbCrLf)

End Sub

'This example produces the following results:
'
'1) Split a string delimited by characters:
'
'1a) The original string is ",ONE,,TWO,,,THREE,,".
'The delimiter character is ','.
'
'1b) Split a string delimited by characters and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'1c) Split a string delimited by characters and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'1d) Split a string delimited by characters and return 2 elements:
'The return value contains these 2 elements:
'<><ONE,,TWO,,,THREE,,>
'
'1e) Split a string delimited by characters and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO,,,THREE,,>
'
'2) Split a string delimited by another string:
'
'2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'The delimiter string is "[stop]".
'
'2b) Split a string delimited by another string and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'2c) Split a string delimited by another string and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'2d) Split a string delimited by another string and return 2 elements:
'The return value contains these 2 elements:
'<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>
'
'2e) Split a string delimited by another string and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO[stop][stop][stop]THREE[stop][stop]>
'

Comentarios

Los caracteres delimitadores no se incluyen en los elementos de la matriz devuelta.

Si esta instancia no contiene ninguno de los caracteres de separator, o el count parámetro es 1, la matriz devuelta consta de un único elemento que contiene esta instancia.

Si el separator parámetro es null o no contiene caracteres, se supone que los caracteres de espacio en blanco son los delimitadores. Los caracteres de espacio en blanco se definen mediante el estándar Unicode y el Char.IsWhiteSpace método devuelve true si se le pasan.

Para pasar null para el char[] separator parámetro , debe indicar el tipo de para null eliminar la ambigüedad de la llamada de otras sobrecargas, como Split(String[], Int32, StringSplitOptions). En el ejemplo siguiente se muestran varias maneras de identificar esta sobrecarga de forma inequívoca.

string phrase = "The quick  brown fox";

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

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

_ = phrase.Split(null as char[], 3, StringSplitOptions.RemoveEmptyEntries);
let phrase = "The quick  brown fox"

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

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

phrase.Split((null: char[]), 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
Dim phrase As String = "The quick brown fox"
Dim words() As String

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

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

Si el count parámetro es cero o el options parámetro es RemoveEmptyEntries y la longitud de esta instancia es cero, se devuelve una matriz vacía.

Cada elemento de separator define un carácter delimitador independiente. Si el options parámetro es Noney dos delimitadores son adyacentes o se encuentra un delimitador al principio o al final de esta instancia, el elemento de matriz correspondiente contiene Empty.

Si hay más de count subcadenas en esta instancia, las primeras count menos 1 subcadenas se devuelven en los primeros count 1 elementos del valor devuelto y los caracteres restantes de esta instancia se devuelven en el último elemento del valor devuelto.

Si count es mayor que el número de subcadenas, se devuelven las subcadenas disponibles y no se produce ninguna excepción.

Consideraciones sobre el rendimiento

Los Split métodos asignan memoria para el objeto de matriz devuelto y un String objeto para cada elemento de matriz. Si la aplicación requiere un rendimiento óptimo o si la administración de la asignación de memoria es fundamental en la aplicación, considere la posibilidad de usar el IndexOf método o IndexOfAny y, opcionalmente, el Compare método , para buscar una subcadena dentro de una cadena.

Si va a dividir una cadena en un carácter separador, use el IndexOf método o IndexOfAny para buscar un carácter separador en la cadena. Si va a dividir una cadena en una cadena separadora, use el IndexOf método o IndexOfAny para buscar el primer carácter de la cadena separadora. A continuación, use el Compare método para determinar si los caracteres después de ese primer carácter son iguales a los caracteres restantes de la cadena separadora.

Además, si se usa el mismo conjunto de caracteres para dividir cadenas en varias Split llamadas de método, considere la posibilidad de crear una sola matriz y hacer referencia a ella en cada llamada de método. Esto reduce significativamente la sobrecarga adicional de cada llamada de método.

Notas a los autores de las llamadas

En .NET Framework 3.5 y versiones anteriores, si el Split(Char[]) método se pasa o separatornull no contiene caracteres, el método usa un conjunto ligeramente diferente de caracteres de espacio en blanco para dividir la cadena que el Trim(Char[]) método para recortar la cadena. A partir de .NET Framework 4, ambos métodos usan un conjunto idéntico de caracteres de espacio en blanco Unicode.

Se aplica a

Split(String, Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de una cadena de delimitación especificada y, opcionalmente, las opciones especificadas.

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

Parámetros

separator
String

Una cadena que delimita las subcadenas de esta instancia.

count
Int32

El número máximo de elementos que se esperan en la matriz.

options
StringSplitOptions

Combinación bit a bit de los valores de enumeración que especifica si se deben recortar subcadenas e incluir subcadenas vacías.

Devoluciones

String[]

Matriz que contiene como máximo count subcadenas de esta instancia que están delimitadas por separator.

Comentarios

Si la cadena ya se ha dividido count : 1 veces, pero no se ha alcanzado el final de la cadena, la última cadena de la matriz devuelta contendrá la subcadena final restante de esta instancia, sin modificar.

Se aplica a

Split(String[], Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de las cadenas de delimitación especificadas y, opcionalmente, las opciones especificadas.

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

Parámetros

separator
String[]

Las cadenas que delimitan las subcadenas de esta cadena, una matriz vacía sin delimitadores o null.

count
Int32

Número máximo de subcadenas que se van devolver.

options
StringSplitOptions

Combinación bit a bit de los valores de enumeración que especifica si se deben recortar subcadenas e incluir subcadenas vacías.

Devoluciones

String[]

Una matriz cuyos elementos contienen las subcadenas de esta cadena que están delimitadas por una o varias cadenas de separator. Para obtener más información, vea la sección Comentarios.

Atributos

Excepciones

count es negativo.

options no es uno de los valores de StringSplitOptions.

Ejemplos

En el ejemplo siguiente se usa la StringSplitOptions enumeración para incluir o excluir subcadenas generadas por el Split método .

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

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

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

/*
This example produces the following results:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

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

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

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

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

// Split a string delimited by characters and return all non-empty elements.
printfn "1c) Split a string delimited by characters and return all non-empty elements:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
show result

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

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

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

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

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

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

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

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

(*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*)
    Dim s1 As String = ",ONE,,TWO,,,THREE,,"
    Dim s2 As String = "[stop]" &
                       "ONE[stop][stop]" &
                       "TWO[stop][stop][stop]" &
                       "THREE[stop][stop]"
    Dim charSeparators() As Char = {","c}
    Dim stringSeparators() As String = {"[stop]"}
    Dim result() As String
    ' ------------------------------------------------------------------------------
    ' Split a string delimited by characters.
    ' ------------------------------------------------------------------------------
    Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)

    ' Display the original string and delimiter characters.
    Console.WriteLine("1a) The original string is ""{0}"".", s1)
    Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))

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

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

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

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

    ' ------------------------------------------------------------------------------
    ' Split a string delimited by another string.
    ' ------------------------------------------------------------------------------
    Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)

    ' Display the original string and delimiter string.
    Console.WriteLine("2a) The original string is ""{0}"".", s2)
    Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))

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

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

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

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

End Sub


' Display the array of separated strings.
Public Shared Sub Show(ByVal entries() As String)
    Console.WriteLine("The return value contains these {0} elements:", entries.Length)
    Dim entry As String
    For Each entry In entries
        Console.Write("<{0}>", entry)
    Next entry
    Console.Write(vbCrLf & vbCrLf)

End Sub

'This example produces the following results:
'
'1) Split a string delimited by characters:
'
'1a) The original string is ",ONE,,TWO,,,THREE,,".
'The delimiter character is ','.
'
'1b) Split a string delimited by characters and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'1c) Split a string delimited by characters and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'1d) Split a string delimited by characters and return 2 elements:
'The return value contains these 2 elements:
'<><ONE,,TWO,,,THREE,,>
'
'1e) Split a string delimited by characters and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO,,,THREE,,>
'
'2) Split a string delimited by another string:
'
'2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'The delimiter string is "[stop]".
'
'2b) Split a string delimited by another string and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'2c) Split a string delimited by another string and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'2d) Split a string delimited by another string and return 2 elements:
'The return value contains these 2 elements:
'<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>
'
'2e) Split a string delimited by another string and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO[stop][stop][stop]THREE[stop][stop]>
'

Comentarios

Las cadenas delimitador no se incluyen en los elementos de la matriz devuelta.

Si esta instancia no contiene ninguna de las cadenas de separator, o el count parámetro es 1, la matriz devuelta consta de un único elemento que contiene esta instancia.

Si el separator parámetro es null o no contiene caracteres, se supone que los caracteres de espacio en blanco son los delimitadores. Los caracteres de espacio en blanco se definen mediante el estándar Unicode y el Char.IsWhiteSpace método devuelve true si se pasan a él.

Para pasar null para el string[] separator parámetro , debe indicar el tipo de para null desambiguar la llamada de otras sobrecargas, como Split(Char[], Int32, StringSplitOptions). En el ejemplo siguiente se muestran varias maneras de identificar de forma inequívoca esta sobrecarga.

string phrase = "The quick  brown fox";

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

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

_ = phrase.Split(null as string[], 3, StringSplitOptions.RemoveEmptyEntries);
let phrase = "The quick  brown fox"

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

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

phrase.Split((null: string[]), 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
Dim phrase As String = "The quick brown fox"
Dim words() As String

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

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

Si el count parámetro es cero o el options parámetro es RemoveEmptyEntries y la longitud de esta instancia es cero, se devuelve una matriz vacía.

Cada elemento de separator define un delimitador independiente que consta de uno o varios caracteres. Si el options parámetro es Noney dos delimitadores son adyacentes o se encuentra un delimitador al principio o al final de esta instancia, el elemento de matriz correspondiente contiene Empty.

Si hay más de count subcadenas en esta instancia, las primeras count menos 1 subcadenas se devuelven en los primeros count 1 elementos del valor devuelto y los caracteres restantes de esta instancia se devuelven en el último elemento del valor devuelto.

Si count es mayor que el número de subcadenas, se devuelven las subcadenas disponibles y no se produce ninguna excepción.

Matriz separadora

Si alguno de los elementos separator de consta de varios caracteres, toda la subcadena se considera un delimitador. Por ejemplo, si uno de los elementos de separator es "10", intenta dividir la cadena "This10is10a10string". devuelve esta matriz de cuatro elementos: { "This", "is", "a", "string". }.

Detalles de comparación

El Split método extrae las subcadenas de esta cadena delimitadas por una o varias de las cadenas del separator parámetro y devuelve esas subcadenas como elementos de una matriz.

El Split método busca delimitadores mediante comparaciones mediante reglas de ordenación ordinal que distinguen mayúsculas de minúsculas. Para obtener más información sobre las ordenación de palabras, cadenas y ordinales, vea la System.Globalization.CompareOptions enumeración .

El Split método omite cualquier elemento de separator cuyo valor es null o la cadena vacía ("").

Para evitar resultados ambiguos cuando las cadenas de separator tienen caracteres en común, el Split método continúa desde el principio hasta el final del valor de la instancia y coincide con el primer elemento de separator que es igual a un delimitador de la instancia. El orden en que se encuentran subcadenas en la instancia tiene prioridad sobre el orden de los elementos de separator.

Por ejemplo, considere una instancia cuyo valor sea "abcdef". Si el primer elemento de separator era "ef" y el segundo elemento era "bcde", el resultado de la operación de división sería "a" y "f". Esto se debe a que la subcadena de la instancia de , "bcde", se encuentra y coincide con un elemento en separator antes de que se encuentre la subcadena "f".

Sin embargo, si el primer elemento de separator era "bcd" y el segundo elemento era "bc", el resultado de la operación de división sería "a" y "ef". Esto se debe a que "bcd" es el primer delimitador de separator que coincide con un delimitador en la instancia de . Si se invierte el orden de los separadores, por lo que el primer elemento era "bc" y el segundo elemento era "bcd", el resultado sería "a" y "def".

Consideraciones de rendimiento

Los Split métodos asignan memoria para el objeto de matriz devuelto y un String objeto para cada elemento de matriz. Si la aplicación requiere un rendimiento óptimo o si la administración de la asignación de memoria es fundamental en la aplicación, considere la posibilidad de usar el IndexOf método o IndexOfAny y, opcionalmente, el Compare método , para buscar una subcadena dentro de una cadena.

Si va a dividir una cadena en un carácter separador, use el IndexOf método o IndexOfAny para buscar un carácter separador en la cadena. Si va a dividir una cadena en una cadena separadora, use el IndexOf método o IndexOfAny para buscar el primer carácter de la cadena separadora. A continuación, use el Compare método para determinar si los caracteres después de ese primer carácter son iguales a los caracteres restantes de la cadena separadora.

Además, si se usa el mismo conjunto de caracteres para dividir cadenas en varias Split llamadas de método, considere la posibilidad de crear una sola matriz y hacer referencia a ella en cada llamada de método. Esto reduce significativamente la sobrecarga adicional de cada llamada de método.

Notas a los autores de las llamadas

En .NET Framework 3.5 y versiones anteriores, si el Split(Char[]) método se pasa o separatornull no contiene caracteres, el método usa un conjunto ligeramente diferente de caracteres de espacio en blanco para dividir la cadena que el Trim(Char[]) método para recortar la cadena. A partir de .NET Framework 4, ambos métodos usan un conjunto idéntico de caracteres de espacio en blanco Unicode.

Se aplica a