Dividir cadenas en subcadenas en C#

Sugerencia

Este artículo forma parte de la sección Aspectos básicos de los desarrolladores que ya conocen al menos un lenguaje de programación y están aprendiendo C#. Si no está familiarizado con la programación, comience primero con los tutoriales de introducción .

¿Vienes de otro lenguaje?string.Split es el equivalente en C# a Java String.split y JavaScript String.prototype.split. A diferencia de esos lenguajes, C# devuelve una matriz (string[]), no una lista, y el argumento separador es un carácter o una cadena, no una expresión regular. Para la división basada en patrones, consulte Regex.Split.

El String.Split método divide una cadena en una matriz de subcadenas mediante uno o varios separadores. Es la manera más sencilla de analizar texto delimitado, como palabras, valores de estilo CSV o tokens de protocolo.

El método tiene muchas sobrecargas, pero cubren cuatro decisiones independientes:

  • Separadores: una char, una matriz de char, una stringo una matriz de string.
  • Número máximo de resultados: límite del número de subcadenas devueltas.
  • Gestión de entradas vacías: mantener subcadenas vacías (el valor predeterminado) o eliminarlas con StringSplitOptions.RemoveEmptyEntries.
  • Control de espacios en blanco: recorte el espacio en blanco inicial y final de cada entrada con StringSplitOptions.TrimEntries.

Dividir una cadena en palabras

Para dividir una frase en el espacio en blanco, pase ' ' como separador:

string phrase = "The quick brown fox jumps over the lazy dog.";
string[] words = phrase.Split(' ');

foreach (var word in words)
{
    Console.WriteLine($"<{word}>");
}
// => <The>
// => <quick>
// => <brown>
// => <fox>
// => <jumps>
// => <over>
// => <the>
// => <lazy>
// => <dog.>

Iteración de la matriz devuelta con for para recuperar la posición de cada palabra:

string phrase = "The quick brown fox jumps over the lazy dog.";
string[] words = phrase.Split(' ');

for (int i = 0; i < words.Length; i++)
{
    Console.WriteLine($"Index {i}: <{words[i]}>");
}
// => Index 0: <The>
// => Index 1: <quick>
// => Index 2: <brown>
// => ...

Si la entrada contiene instancias repetidas del carácter separador, Split genera entradas vacías, una para cada "hueco" entre separadores consecutivos:

string phrase = "The quick brown    fox     jumps over the lazy dog.";
string[] words = phrase.Split(' ');

foreach (var word in words)
{
    Console.WriteLine($"<{word}>");
}
// The runs of spaces produce empty entries:
// => <The>
// => <quick>
// => <brown>
// => <>
// => <>
// => <>
// => <fox>
// => ...

Pase StringSplitOptions.RemoveEmptyEntries para quitar esas entradas vacías, como se muestra más adelante en este artículo.

Dividir en varios caracteres separadores

Cuando más de un carácter puede actuar como separador, páselos como una matriz. En el ejemplo siguiente, se consideran espacios, comas, puntos, dos puntos y tabulaciones como delimitadores de palabras:

char[] delimiters = [' ', ',', '.', ':', '\t'];

string text = "one\ttwo three:four,five six seven";
Console.WriteLine($"Original text: '{text}'");

string[] words = text.Split(delimiters);
Console.WriteLine($"{words.Length} words in text:");

foreach (var word in words)
{
    Console.WriteLine($"<{word}>");
}
// => 7 words in text:
// => <one>
// => <two>
// => <three>
// => <four>
// => <five>
// => <six>
// => <seven>

Los separadores adyacentes siguen produciendo entradas vacías:

char[] delimiters = [' ', ',', '.', ':', '\t'];

string text = "one\ttwo :,five six seven";
Console.WriteLine($"Original text: '{text}'");

string[] words = text.Split(delimiters);
Console.WriteLine($"{words.Length} words in text:");

foreach (var word in words)
{
    Console.WriteLine($"<{word}>");
}
// => 7 words in text:
// => <one>
// => <two>
// => <>
// => <>
// => <five>
// => <six>
// => <seven>

Dividir usando separadores de varios caracteres

Para dividir usando separadores de palabras completas o de varios caracteres, pase un array de cadenas. Las sobrecargas de la matriz de cadenas requieren un StringSplitOptions valor. Se usa RemoveEmptyEntries cuando los separadores repetidos generarían resultados vacíos:

string[] separators = ["<<", "..."];

string text = "one<<two......three<four";
Console.WriteLine($"Original text: '{text}'");

string[] words = text.Split(separators, StringSplitOptions.RemoveEmptyEntries);
Console.WriteLine($"{words.Length} substrings in text:");

foreach (var word in words)
{
    Console.WriteLine(word);
}
// => 3 substrings in text:
// => one
// => two
// => three<four

Limitar el número de subcadenas que se devuelven

Pase un count argumento para limitar el número de resultados. La entrada final contiene todo lo que queda, incluidos los separadores restantes:

string phrase = "The quick brown fox jumps over the lazy dog.";
string[] words = phrase.Split(' ', 4, StringSplitOptions.None);

foreach (var word in words)
{
    Console.WriteLine($"<{word}>");
}
// => <The>
// => <quick>
// => <brown>
// => <fox jumps over the lazy dog.>

Este patrón es útil para key=value pares y otros formatos donde solo el primer separador es significativo.

Recorte del espacio en blanco de cada entrada

StringSplitOptions.TrimEntries elimina los espacios en blanco iniciales y finales de cada subcadena devuelta. Puede combinarlo con RemoveEmptyEntries para la limpieza típica de estilo CSV:

string numerals = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10";
string[] trimmed = numerals.Split(',', StringSplitOptions.TrimEntries);

Console.WriteLine("Trimmed entries:");
foreach (var word in trimmed)
{
    Console.WriteLine($"<{word}>");
}

string[] untrimmed = numerals.Split(',', StringSplitOptions.None);
Console.WriteLine("Untrimmed entries:");
foreach (var word in untrimmed)
{
    Console.WriteLine($"<{word}>");
}
// => Trimmed entries: <1> <2> ... <10>
// => Untrimmed entries: <1> < 2> ... < 10>

Usa expresiones regulares

Split funciona bien para delimitadores de cadenas o caracteres fijos. Para la división basada en patrones, use Regex.Split. Para obtener una introducción a las expresiones regulares en cadenas, consulte Operaciones de cadena.

Consulte también

  • Last updated on