Dividir cadeias de caracteres em subcadeias no C#

Sugestão

Este artigo faz parte da secção Fundamentos para programadores que já conhecem pelo menos uma linguagem de programação e estão a aprender C#. Se és novo na programação, começa primeiro pelos tutoriais para começar .

Vindo de outra linguagem?string.Split é o equivalente do C# ao String.split do Java e ao String.prototype.split do JavaScript. Ao contrário dessas linguagens, C# devolve um array (string[]), não uma lista, e o argumento separador é um carácter ou cadeia, não uma expressão regular. Para divisão baseada em padrões, veja Regex.Split.

O String.Split método divide uma cadeia numa matriz de subcadeias usando um ou mais separadores. É a forma mais simples de analisar textos delimitados, como palavras, valores ao estilo CSV ou tokens de protocolo.

O método tem muitas sobrecargas, mas abrangem quatro decisões independentes:

  • Separadores: um char, um array de char, um string, ou um array de string.
  • Contagem máxima de resultados: limitar o número de subcadeias devolvidas.
  • Tratamento de entradas vazias: manter substrings vazias (o padrão) ou eliminá-las com StringSplitOptions.RemoveEmptyEntries.
  • Gestão de espaços em branco: cortar espaços em branco à frente e à saída de cada entrada com StringSplitOptions.TrimEntries.

Dividir uma cadeia de caracteres em palavras

Para separar uma frase em espaços em branco, passe ' ' por 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.>

Itere o array devolvido com for para recuperar a posição de cada palavra:

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>
// => ...

Se a entrada contiver instâncias repetidas do carácter separador, Split produz entradas vazias, uma para cada "intervalo" 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>
// => ...

Passe StringSplitOptions.RemoveEmptyEntries para eliminar essas entradas vazias, como mostrado mais adiante neste artigo.

Divisão em múltiplos caracteres separadores

Quando mais de um carácter puder servir de separador, passe esses caracteres como um array. O exemplo seguinte considera espaços, vírgulas, pontos, dois-pontos e tabulações como limites de palavras:

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>

Os separadores adjacentes continuam a produzir entradas vazias:

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 por separadores de vários caracteres

Para dividir utilizando palavras completas ou separadores com vários caracteres, passe uma matriz de cadeias de caracteres. As sobrecargas de matriz de cadeias de caracteres requerem um valor StringSplitOptions. Utilize RemoveEmptyEntries quando separadores repetidos produziriam, de outro modo, resultados vazios:

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

Limita o número de substrings que recebes de volta

Aprove um count argumento para limitar o número de resultados. A última entrada contém tudo o que resta, incluindo quaisquer 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 padrão é útil para key=value pares e outros formatos onde apenas o primeiro separador tem significado.

Cortar o espaço em branco de cada entrada

StringSplitOptions.TrimEntries remove os espaços em branco no início e no fim de cada subcadeia devolvida. Pode combiná-lo com RemoveEmptyEntries para uma limpeza típica de 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>

Usar expressões regulares

Split Funciona bem para delimitadores fixos de caracteres ou strings. Para divisão baseada em padrões, use Regex.Split. Para uma introdução às expressões regulares em cadeias, veja Operações de cadeia.

Ver também

  • Last updated on