Modifier le contenu de chaîne en C#

Tip

Cet article fait partie de la section Notions de base pour les développeurs qui connaissent déjà au moins un langage de programmation et apprennent C#. Si vous débutez avec la programmation, commencez par commencer par les didacticiels De prise en main .

Venant d’une autre langue ? Comme Java et JavaScript, les chaînes C# sont immuables : les méthodes telles que Replace et Trim retournent une nouvelle chaîne au lieu de modifier l’original. Les motifs présentés ici correspondent aux méthodes String dans ces langages.

Un C# string est immuable, ce qui signifie que son contenu ne change jamais après sa création. Chaque méthode qui semble modifier une chaîne retourne en fait une nouvelle string avec les modifications, laissant l’original intact. Les exemples de cet article stockent chaque résultat dans une nouvelle variable afin de voir à la fois la source et la valeur modifiée.

Choisissez la technique qui correspond à votre scénario : remplacez le texte connu, supprimez un espace blanc, supprimez une étendue de caractères, remplacez le texte correspondant à un modèle ou modifiez des caractères individuels.

Remplacer le texte connu

La String.Replace méthode remplace chaque occurrence d’une chaîne par une autre et retourne le résultat sous la forme d’une nouvelle chaîne :

string source = "The mountains are behind the clouds today.";

// Replace returns a new string; the original is unchanged.
string updated = source.Replace("mountains", "peaks");

Console.WriteLine(source);
// => The mountains are behind the clouds today.
Console.WriteLine(updated);
// => The peaks are behind the clouds today.

La chaîne d’origine est inchangée, ce qui illustre l’immuabilité : Replace crée une chaîne avec la substitution.

Replace présente également une surcharge qui permute des caractères individuels. L’exemple suivant remplace chaque espace par un trait de soulignement :

string source = "The mountains are behind the clouds today.";

// Replace every occurrence of one character with another.
string updated = source.Replace(' ', '_');

Console.WriteLine(updated);
// => The_mountains_are_behind_the_clouds_today.

Les deux surcharges remplacent chaque occurrence dans la chaîne de caractères, et pas seulement la première. Que vous transmettiez un caractère unique ou une chaîne, Replace substitue toutes les occurrences d’un appel.

Découper les espaces blancs

Utilisez String.Trim, String.TrimStartet String.TrimEnd pour supprimer les espaces blancs de début ou de fin. Chaque méthode retourne une nouvelle chaîne :

string source = "    I'm wider than I need to be.      ";

// Each method returns a new string with whitespace removed.
Console.WriteLine($"<{source.Trim()}>");
// => <I'm wider than I need to be.>
Console.WriteLine($"<{source.TrimStart()}>");
// => <I'm wider than I need to be.      >
Console.WriteLine($"<{source.TrimEnd()}>");
// => <    I'm wider than I need to be.>

Supprimer une plage de caractères

La String.Remove méthode supprime un certain nombre de caractères à partir d’un index. Combinez-le String.IndexOf pour localiser le texte à supprimer :

string source = "Many mountains are behind many clouds today.";
string toRemove = "many ";

// Find the text, then remove that span by index and length.
int index = source.IndexOf(toRemove);
string result = index >= 0
    ? source.Remove(index, toRemove.Length)
    : source;

Console.WriteLine(result);
// => Many mountains are behind clouds today.

Remplacer le texte qui correspond à un modèle

Lorsque vous devez remplacer du texte qui suit un modèle plutôt qu’une chaîne exacte, utilisez des expressions régulières. La Regex.Replace méthode accepte une fonction qui calcule chaque remplacement. Vous pouvez donc conserver des détails tels que la mise en majuscule d’origine. Le modèle the\s correspond à « the » suivi d’un caractère d’espace blanc, ce qui l’empêche de correspondre à « there » :

string source = "The mountains are still there behind the clouds today.";

// Replace "the" or "The" followed by whitespace, preserving the original case.
// The \s in the pattern keeps "there" from matching.
string result = Regex.Replace(
    source,
    """the\s""",
    match => char.IsUpper(match.Value[0]) ? "Many " : "many ",
    RegexOptions.IgnoreCase);

Console.WriteLine(result);
// => Many mountains are still there behind many clouds today.

Pour la recherche basée sur des modèles plutôt que le remplacement, consultez les chaînes de recherche en C#. Pour obtenir la syntaxe de l’expression régulière, consultez la référence rapide du langage d’expression régulière.

Modifier des caractères individuels

Pour modifier les caractères par position, copiez la chaîne dans un Span<T> caractère, modifiez l’étendue, puis générez une nouvelle chaîne à partir de celle-ci. L’exemple suivant recherche le mot « fox » et le remplace par « cat » :

string phrase = "The quick brown fox jumps over the fence.";

// A string is immutable, so copy it into a Span<char> to edit in place.
Span<char> characters = stackalloc char[phrase.Length];
phrase.CopyTo(characters);
int index = phrase.IndexOf("fox");
if (index != -1)
{
    characters[index] = 'c';
    characters[index + 1] = 'a';
    characters[index + 2] = 't';
}

// Build a new string from the modified characters.
string updated = new string(characters);
Console.WriteLine(updated);
// => The quick brown cat jumps over the fence.

Pour les scénarios hautes performances qui évitent les allocations intermédiaires, le runtime fournit des API de niveau inférieur, telles que String.Create. Ces techniques sont avancées ; pour le code quotidien, les méthodes de cet article sont le bon choix.

Voir aussi

  • Last updated on