Comment modifier le contenu d’une chaîne en C#How to modify string contents in C#

Cet article présente plusieurs techniques pour produire un string en modifiant un string existant.This article demonstrates several techniques to produce a string by modifying an existing string. Toutes les techniques présentées retournent le résultat des modifications sous la forme d’un nouvel objet string.All the techniques demonstrated return the result of the modifications as a new string object. Pour démontrer que les chaînes d’origine et modifiées sont des instances distinctes, les exemples stockent le résultat dans une nouvelle variable.To demonstrate that the original and modified strings are distinct instances, the examples store the result in a new variable. Vous pouvez examiner les originaux string et les nouveaux, modifiés string lorsque vous exécutez chaque exemple.You can examine the original string and the new, modified string when you run each example.

Notes

Les exemples C# de cet article s’exécutent dans l’exécuteur et le terrain de jeu du code inline Try.NET.The C# examples in this article run in the Try.NET inline code runner and playground. Sélectionnez le bouton Exécuter pour exécuter un exemple dans une fenêtre interactive.Select the Run button to run an example in an interactive window. Une fois que vous avez exécuté le code, vous pouvez le modifier et exécuter le code modifié en resélectionnant Exécuter.Once you execute the code, you can modify it and run the modified code by selecting Run again. La code modifié s’exécute dans la fenêtre interactive ou, si la compilation échoue, la fenêtre interactive affiche tous les messages d’erreur du compilateur C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Plusieurs techniques sont présentées dans cet article.There are several techniques demonstrated in this article. Vous pouvez remplacer du texte existant.You can replace existing text. Vous pouvez rechercher des modèles et remplacer le texte correspondant par un autre texte.You can search for patterns and replace matching text with other text. Vous pouvez traiter une chaîne en tant que séquence de caractères.You can treat a string as a sequence of characters. Vous pouvez également utiliser des méthodes pratiques qui suppriment les espaces blancs.You can also use convenience methods that remove white space. Choisissez les techniques qui correspondent le mieux à votre scénario.Choose the techniques that most closely match your scenario.

Remplacer du texteReplace text

Le code suivant crée une chaîne en remplaçant le texte existant par un substitut.The following code creates a new string by replacing existing text with a substitute.

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

// Replace one substring with another with String.Replace.
// Only exact matches are supported.
var replacement = source.Replace("mountains", "peaks");
Console.WriteLine($"The source string is <{source}>");
Console.WriteLine($"The updated string is <{replacement}>");

Le code précédent illustre la propriété immuable des chaînes.The preceding code demonstrates this immutable property of strings. Vous pouvez voir dans l’exemple précédent que la chaîne d’origine, source, n’est pas modifiée.You can see in the preceding example that the original string, source, is not modified. La méthode String.Replace crée un string contenant les modifications.The String.Replace method creates a new string containing the modifications.

La méthode Replace peut remplacer des chaînes ou des caractères uniques.The Replace method can replace either strings or single characters. Dans les deux cas, toutes les occurrences du texte recherché sont remplacées.In both cases, every occurrence of the sought text is replaced. L’exemple suivant remplace tous les caractères ' ' par '_' :The following example replaces all ' ' characters with '_':

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

// Replace all occurrences of one char with another.
var replacement = source.Replace(' ', '_');
Console.WriteLine(source);
Console.WriteLine(replacement);

La chaîne source ne change pas, et une nouvelle chaîne est retournée avec le remplacement.The source string is unchanged, and a new string is returned with the replacement.

Supprimer les espaces blancsTrim white space

Vous pouvez utiliser les méthodes String.Trim, String.TrimStart et String.TrimEnd pour supprimer les espaces blancs de début ou de fin.You can use the String.Trim, String.TrimStart, and String.TrimEnd methods to remove any leading or trailing white space. Le code suivant montre un exemple de chaque.The following code shows an example of each. La chaîne source ne change pas. Ces méthodes retournent une nouvelle chaîne avec le contenu modifié.The source string does not change; these methods return a new string with the modified contents.

// Remove trailing and leading white space.
string source = "    I'm wider than I need to be.      ";
// Store the results in a new string variable.
var trimmedResult = source.Trim();
var trimLeading = source.TrimStart();
var trimTrailing = source.TrimEnd();
Console.WriteLine($"<{source}>");
Console.WriteLine($"<{trimmedResult}>");
Console.WriteLine($"<{trimLeading}>");
Console.WriteLine($"<{trimTrailing}>");

Supprimer du texteRemove text

Vous pouvez supprimer du texte d’une chaîne à l’aide de la méthode String.Remove.You can remove text from a string using the String.Remove method. Cette méthode supprime un certain nombre de caractères en commençant à un index spécifique.This method removes a number of characters starting at a specific index. L’exemple suivant montre comment utiliser String.IndexOf suivi de Remove pour supprimer le texte d’une chaîne :The following example shows how to use String.IndexOf followed by Remove to remove text from a string:

string source = "Many mountains are behind many clouds today.";
// Remove a substring from the middle of the string.
string toRemove = "many ";
string result = string.Empty;
int i = source.IndexOf(toRemove);
if (i >= 0)
{
    result= source.Remove(i, toRemove.Length);
}
Console.WriteLine(source);
Console.WriteLine(result);

Remplacer du texte correspondant à un modèleReplace matching patterns

Vous pouvez utiliser des expressions régulières pour remplacer du texte correspondant à un modèle par un autre texte, éventuellement défini par un modèle.You can use regular expressions to replace text matching patterns with new text, possibly defined by a pattern. L’exemple suivant utilise la classe System.Text.RegularExpressions.Regex pour trouver un modèle dans une chaîne source et le remplacer par du texte dont la casse est correcte.The following example uses the System.Text.RegularExpressions.Regex class to find a pattern in a source string and replace it with proper capitalization. La méthode Regex.Replace(String, String, MatchEvaluator, RegexOptions) accepte dans ses arguments une fonction qui fournit la logique du remplacement.The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method takes a function that provides the logic of the replacement as one of its arguments. Dans cet exemple, la fonction LocalReplaceMatchCase est une fonction locale déclarée à l’intérieur de l’exemple de méthode.In this example, that function, LocalReplaceMatchCase is a local function declared inside the sample method. LocalReplaceMatchCase utilise la classe System.Text.StringBuilder pour générer la chaîne de remplacement avec la casse correcte.LocalReplaceMatchCase uses the System.Text.StringBuilder class to build the replacement string with proper capitalization.

Les expressions régulières sont plus utiles pour rechercher et remplacer du texte qui suit un modèle que du texte connu.Regular expressions are most useful for searching and replacing text that follows a pattern, rather than known text. Pour plus d’informations, consultez Comment rechercher des chaînes.For more information, see How to search strings. Le modèle de recherche, « the\s », recherche le mot « the » suivi d’un espace blanc.The search pattern, "the\s" searches for the word "the" followed by a white-space character. Cette partie du modèle permet d’exclure le mot « there » qui figure dans la chaîne source.That part of the pattern ensures that it doesn't match "there" in the source string. Pour plus d’informations sur les éléments du langage des expressions régulières, consultez Langage des expressions régulières - Aide-mémoire.For more information on regular expression language elements, see Regular Expression Language - Quick Reference.

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

// Use Regex.Replace for more flexibility.
// Replace "the" or "The" with "many" or "Many".
// using System.Text.RegularExpressions
string replaceWith = "many ";
source = System.Text.RegularExpressions.Regex.Replace(source, "the\\s", LocalReplaceMatchCase,
    System.Text.RegularExpressions.RegexOptions.IgnoreCase);
Console.WriteLine(source);

string LocalReplaceMatchCase(System.Text.RegularExpressions.Match matchExpression)
{
    // Test whether the match is capitalized
    if (Char.IsUpper(matchExpression.Value[0]))
    {
        // Capitalize the replacement string
        System.Text.StringBuilder replacementBuilder = new System.Text.StringBuilder(replaceWith);
        replacementBuilder[0] = Char.ToUpper(replacementBuilder[0]);
        return replacementBuilder.ToString();
    }
    else
    {
        return replaceWith;
    }
}

La méthode StringBuilder.ToString retourne une chaîne immuable avec le contenu dans l’objet StringBuilder.The StringBuilder.ToString method returns an immutable string with the contents in the StringBuilder object.

Modification de caractères individuelsModifying individual characters

Vous pouvez générer un tableau de caractères à partir d’une chaîne, modifier le contenu du tableau, puis créer une autre chaîne à partir du contenu modifié du tableau.You can produce a character array from a string, modify the contents of the array, and then create a new string from the modified contents of the array.

L’exemple suivant montre comment remplacer un jeu de caractères dans une chaîne.The following example shows how to replace a set of characters in a string. Tout d’abord, il utilise la méthode String.ToCharArray() pour créer un tableau de caractères.First, it uses the String.ToCharArray() method to create an array of characters. Il utilise la méthode IndexOf pour trouver l’index de départ du mot « fox ».It uses the IndexOf method to find the starting index of the word "fox." Les trois caractères suivants sont remplacés par un autre mot.The next three characters are replaced with a different word. Enfin, une nouvelle chaîne est construite à partir du tableau de caractères mis à jour.Finally, a new string is constructed from the updated character array.

string phrase = "The quick brown fox jumps over the fence";
Console.WriteLine(phrase);

char[] phraseAsChars = phrase.ToCharArray();
int animalIndex = phrase.IndexOf("fox");
if (animalIndex != -1)
{
    phraseAsChars[animalIndex++] = 'c';
    phraseAsChars[animalIndex++] = 'a';
    phraseAsChars[animalIndex] = 't';
}

string updatedPhrase = new string(phraseAsChars);
Console.WriteLine(updatedPhrase);

Créer un contenu de chaîne par programmationProgrammatically build up string content

Étant donné que les chaînes sont immuables, les exemples précédents créent tous des chaînes temporaires ou des tableaux de caractères.Since strings are immutable, the previous examples all create temporary strings or character arrays. Dans les scénarios à hautes performances, il peut être souhaitable d’éviter ces allocations de tas.In high-performance scenarios, it may be desirable to avoid these heap allocations. .NET Core fournit une String.Create méthode qui vous permet de remplir par programmation le contenu de caractères d’une chaîne via un rappel tout en évitant les allocations de chaînes temporaires intermédiaires..NET Core provides a String.Create method that allows you to programmatically fill in the character content of a string via a callback while avoiding the intermediate temporary string allocations.

// constructing a string from a char array, prefix it with some additional characters
char[] chars = { 'a', 'b', 'c', 'd', '\0' };
int length = chars.Length + 2;
string result = string.Create(length, chars, (Span<char> strContent, char[] charArray) =>
{
    strContent[0] = '0';
    strContent[1] = '1';
    for (int i = 0; i < charArray.Length; i++)
    {
        strContent[i + 2] = charArray[i];
    }
});

Console.WriteLine(result);

Vous pouvez modifier une chaîne dans un bloc fixed avec du code unsafe, mais il est fortement déconseillé de modifier le contenu de la chaîne après la création d’une chaîne.You could modify a string in a fixed block with unsafe code, but it is strongly discouraged to modify the string content after a string is created. Cela entraînera une rupture des choses de manière imprévisible.Doing so will break things in unpredictable ways. Par exemple, si quelqu’un effectue une chaîne qui a le même contenu que le vôtre, il obtient votre copie et ne s’attend pas à ce que vous modifiiez sa chaîne.For example, if someone interns a string that has the same content as yours, they'll get your copy and won't expect that you are modifying their string.

Voir aussiSee also