Supprimer un caractère d'une chaîne en C#

Pour supprimer un caractère connu d’une chaîne C#, appelez string.Replace() avec ce caractère et string.Empty. Pour supprimer plusieurs caractères choisis, répétez l’opération pour chacun d’eux. Les chaînes sont immuables : chaque appel renvoie une nouvelle chaîne. Affectez le résultat si vous souhaitez conserver la modification. Utilisez string.Split() avec string.Join() lorsque les caractères sont des délimiteurs, Regex.Replace() pour un motif de caractères, ou LINQ lorsque la règle précise quels caractères conserver. Pour supprimer spécifiquement les espaces blancs, consultez comment supprimer les espaces blancs d’une chaîne en C#.

Supprimer des caractères avec string.Replace()

string.Replace() remplace toutes les occurrences d’un caractère ou d’une sous-chaîne spécifiés. Remplacer un caractère par string.Empty supprime ses occurrences. L’exemple suivant applique cette opération à chaque élément d’un ensemble choisi ; la valeur renvoyée par chaque appel devient l’entrée de l’appel suivant.

Exécutez cet exemple :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

using System;

class Program
{
    static void Main()
    {
        string text = "Something @to ,Write.;';";
        char[] charactersToRemove = { '@', ',', '.', ';', '\'' };

        foreach (char character in charactersToRemove)
        {
            text = text.Replace(character.ToString(), string.Empty);
        }

        Console.WriteLine(text);
    }
}

Something to Write

Pour un seul caractère, un appel suffit, par exemple : text = text.Replace("@", string.Empty);. La méthode supprime toutes les correspondances, et pas seulement la première. Si l’ensemble choisi est volumineux, les appels répétés parcourent de nouveau la chaîne et créent des chaînes intermédiaires ; envisagez un filtre de caractères ou une expression régulière si sa règle est plus claire.

Supprimer des délimiteurs avec string.Split() et string.Join()

string.Split() traite chaque caractère spécifié comme un délimiteur et renvoie les sous-chaînes situées entre les délimiteurs. string.Join() concatène ces éléments avec le séparateur fourni. Un séparateur vide assemble directement les éléments restants et supprime ainsi les délimiteurs. Cette approche exprime l’opération autrement ; elle n’est pas intrinsèquement meilleure que string.Replace().

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

using System;

class Program
{
    static void Main()
    {
        string text = "Something @to ,Write.;';";
        char[] delimiters = { '@', ',', '.', ';', '\'' };
        string result = string.Join(string.Empty,
            text.Split(delimiters, StringSplitOptions.RemoveEmptyEntries));

        Console.WriteLine(result);
    }
}

Something to Write

StringSplitOptions.RemoveEmptyEntries écarte les éléments vides qui peuvent apparaître lorsque des délimiteurs se suivent ou se trouvent au début ou à la fin. Pour l’entrée présentée, la concaténation des éléments découpés produit le même texte visible que la boucle de remplacement. Utilisez cette approche lorsque le découpage en éléments est utile en soi ; pour une simple suppression de caractères, string.Replace() est plus direct.

Supprimer des caractères avec Regex.Replace()

Regex.Replace() remplace chaque sous-chaîne correspondant à un motif d’expression régulière. Une classe de caractères telle que [@,.;'] correspond à n’importe lequel des caractères indiqués ; remplacer les correspondances par string.Empty supprime donc cet ensemble choisi. Des caractères comme . ont une signification particulière dans les expressions régulières en dehors d’une classe de caractères ; ici, le point est littéral.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "Something @to ,Write.;';";
        string result = Regex.Replace(text, "[@,.;']", string.Empty);

        Console.WriteLine(result);
    }
}

Something to Write

Une expression régulière est utile lorsque la règle de suppression décrit un motif, comme une plage ou une catégorie de caractères, plutôt qu’une courte liste fixe. Échappez les métacaractères des expressions régulières lorsqu’ils doivent correspondre littéralement en dehors d’une classe de caractères. Pour une liste fixe, string.Replace() ou string.Split() permet de voir plus clairement quels caractères sont concernés.

Filtrer les caractères avec LINQ

LINQ peut construire une nouvelle chaîne à partir des caractères qui satisfont une condition. Cet exemple conserve les espaces blancs, les lettres et les chiffres ; la ponctuation est donc supprimée. Il s’agit d’un filtre fondé sur les propriétés des caractères, et non de la suppression d’un ensemble choisi arbitrairement par l’appelant : tous les caractères correspondant à la règle sont conservés, y compris les lettres et les espaces.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string text = "Something @to ,Write.;';";
        string result = new string(text
            .Where(character => char.IsWhiteSpace(character)
                || char.IsLetterOrDigit(character))
            .ToArray());

        Console.WriteLine(result);
    }
}

Something to Write

Utilisez LINQ lorsque la condition de conservation des caractères exprime le plus clairement le besoin. Remplacez char.IsWhiteSpace et char.IsLetterOrDigit par un prédicat adapté à votre règle si vous avez besoin d’un autre ensemble. Pour une liste de caractères précis fournie par l’appelant, utilisez plutôt la boucle de remplacement ou un test d’appartenance équivalent.