Fractionner des chaînes en sous-chaînes en C#

La String.Split méthode divise une chaîne en un tableau de sous-chaînes à l’aide d’un ou plusieurs séparateurs. Il s’agit du moyen le plus simple d’analyser du texte délimité tel que des mots, des valeurs de style CSV ou des jetons de protocole.

La méthode a de nombreuses surcharges, mais elles couvrent quatre décisions indépendantes :

• Séparateurs : un char, tableau de char, un stringou un tableau de string.
• Nombre maximal de résultats : limitez le nombre de sous-chaînes retournées.
• Gestion des entrées vides : conservez les sous-chaînes vides (valeur par défaut) ou supprimez-les avec StringSplitOptions.RemoveEmptyEntries.
• Gestion des espaces blancs : découper les espaces blancs de début et de fin de chaque entrée avec StringSplitOptions.TrimEntries.

Fractionner une chaîne en mots

Pour fractionner une expression sur l’espace blanc, passez ' ' en tant que séparateur :

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

Parcourez le tableau renvoyé avec for pour récupérer la position de chaque mot :

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 l’entrée contient des instances répétées du caractère séparateur, Split produit des entrées vides, une pour chaque « écart » entre les séparateurs consécutifs :

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

Passez StringSplitOptions.RemoveEmptyEntries pour supprimer ces entrées vides, comme indiqué plus loin dans cet article.

Diviser selon plusieurs caractères séparateurs

Lorsque plusieurs caractères peuvent servir de séparateur, passez-les sous forme de tableau. L’exemple suivant traite les espaces, les virgules, les points, les deux-points et les onglets comme des limites de mots :

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>

Les séparateurs adjacents produisent toujours des entrées vides :

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>

Scinder selon des séparateurs multicharactères

Pour fractionner à l’aide de séparateurs constitués de mots entiers ou de plusieurs caractères, utilisez un tableau de chaînes. Les surcharges de tableau de chaînes de caractères nécessitent une valeur StringSplitOptions. Utilisez RemoveEmptyEntries lorsque des séparateurs répétés produisent sinon des résultats vides :

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

Limiter le nombre de sous-chaînes que vous récupérez

Passez un count argument pour limiter le nombre de résultats. La dernière entrée regroupe tout ce qui reste, y compris les séparateurs restants :

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

Ce modèle est pratique pour key=value les paires et d’autres formats où seul le premier séparateur est significatif.

Découper les espaces blancs de chaque entrée

StringSplitOptions.TrimEntries supprime les espaces de début et de fin de chaque sous-chaîne renvoyée. Vous pouvez le combiner avec RemoveEmptyEntries pour un nettoyage classique de type 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>

Utiliser des expressions régulières

Split fonctionne bien pour les délimiteurs de caractères fixes ou de chaîne. Pour le fractionnement basé sur des modèles, utilisez Regex.Split. Pour obtenir une présentation des expressions régulières sur des chaînes, consultez les opérations de chaîne.

Voir aussi

• String.Split
• System.StringSplitOptions
• Opérations de chaîne : correspondance de modèles, performances et recherche basée sur l’étendue
• Extraire des éléments d’une chaîne