Comment supprimer tous les caractères non alphanumériques d'une chaîne à l'exception du tiret?

Comment supprimer tous les caractères non alphanumériques d'une chaîne à l'exception des tirets et des espaces?

Remplacez [^a-zA-Z0-9 -]par une chaîne vide.

Regex rgx = new Regex("[^a-zA-Z0-9 -]");
str = rgx.Replace(str, "");

J'aurais pu utiliser RegEx, ils peuvent fournir une solution élégante mais ils peuvent causer des problèmes de performance. Voici une solution

char[] arr = str.ToCharArray();

arr = Array.FindAll<char>(arr, (c => (char.IsLetterOrDigit(c) 
                                  || char.IsWhiteSpace(c) 
                                  || c == '-')));
str = new string(arr);

Lors de l'utilisation du cadre compact (qui n'a pas FindAll)

Remplacez FindAll par ¹

char[] arr = str.Where(c => (char.IsLetterOrDigit(c) || 
                             char.IsWhiteSpace(c) || 
                             c == '-')).ToArray(); 

str = new string(arr);

¹ Commentaire par ShawnFeatherly

Tu peux essayer:

string s1 = Regex.Replace(s, "[^A-Za-z0-9 -]", "");

Où sest ta chaîne.

Utilisation de System.Linq

string withOutSpecialCharacters = new string(stringWithSpecialCharacters.Where(c =>char.IsLetterOrDigit(c) || char.IsWhiteSpace(c) || c == '-').ToArray());

Le regex est [^\w\s\-]*:

\sest préférable d'utiliser à la place de space ( ), car il peut y avoir un onglet dans le texte.

Sur la base de la réponse à cette question, j'ai créé une classe statique et ajouté ces derniers. Je pensais que cela pourrait être utile pour certaines personnes.

public static class RegexConvert
{
    public static string ToAlphaNumericOnly(this string input)
    {
        Regex rgx = new Regex("[^a-zA-Z0-9]");
        return rgx.Replace(input, "");
    }

    public static string ToAlphaOnly(this string input)
    {
        Regex rgx = new Regex("[^a-zA-Z]");
        return rgx.Replace(input, "");
    }

    public static string ToNumericOnly(this string input)
    {
        Regex rgx = new Regex("[^0-9]");
        return rgx.Replace(input, "");
    }
}

Ensuite, les méthodes peuvent être utilisées comme:

string example = "asdf1234!@#$";
string alphanumeric = example.ToAlphaNumericOnly();
string alpha = example.ToAlphaOnly();
string numeric = example.ToNumericOnly();

Vous voulez quelque chose de rapide?

public static class StringExtensions 
{
    public static string ToAlphaNumeric(this string self, params char[] allowedCharacters)
    {
        return new string(Array.FindAll(self.ToCharArray(), c => char.IsLetterOrDigit(c) || allowedCharacters.Contains(c)));
    }
}

Cela vous permettra également de spécifier les caractères que vous souhaitez autoriser.

Voici une solution rapide conviviale d'allocation de tas non regex qui était ce que je cherchais.

Édition non sécurisée.

public static unsafe void ToAlphaNumeric(ref string input)
{
    fixed (char* p = input)
    {
        int offset = 0;
        for (int i = 0; i < input.Length; i++)
        {
            if (char.IsLetterOrDigit(p[i]))
            {
                p[offset] = input[i];
                offset++;
            }
        }
        ((int*)p)[-1] = offset; // Changes the length of the string
        p[offset] = '\0';
    }
}

Et pour ceux qui ne veulent pas utiliser dangereux ou ne font pas confiance au hack de longueur de chaîne.

public static string ToAlphaNumeric(string input)
{
    int j = 0;
    char[] newCharArr = new char[input.Length];

    for (int i = 0; i < input.Length; i++)
    {
        if (char.IsLetterOrDigit(input[i]))
        {
            newCharArr[j] = input[i];
            j++;
        }
    }

    Array.Resize(ref newCharArr, j);

    return new string(newCharArr);
}

J'ai fait une solution différente, en éliminant les caractères de contrôle , ce qui était mon problème d'origine.

C'est mieux que de mettre dans une liste tous les caractères "spéciaux mais bons"

char[] arr = str.Where(c => !char.IsControl(c)).ToArray();    
str = new string(arr);

c'est plus simple, donc je pense que c'est mieux!

Voici une méthode d'extension utilisant la réponse @ata comme source d'inspiration.

"hello-world123, 456".MakeAlphaNumeric(new char[]{'-'});// yields "hello-world123456"

ou si vous avez besoin de caractères supplémentaires autres que le trait d'union ...

"hello-world123, 456!?".MakeAlphaNumeric(new char[]{'-','!'});// yields "hello-world123456!"


public static class StringExtensions
{   
    public static string MakeAlphaNumeric(this string input, params char[] exceptions)
    {
        var charArray = input.ToCharArray();
        var alphaNumeric = Array.FindAll<char>(charArray, (c => char.IsLetterOrDigit(c)|| exceptions?.Contains(c) == true));
        return new string(alphaNumeric);
    }
}

J'utilise ici une variante de l'une des réponses. Je veux remplacer les espaces par "-" afin que son référencement soit convivial et également en minuscules. Ne référence pas non plus system.web à partir de ma couche de services.

private string MakeUrlString(string input)
{
    var array = input.ToCharArray();

    array = Array.FindAll<char>(array, c => char.IsLetterOrDigit(c) || char.IsWhiteSpace(c) || c == '-');

    var newString = new string(array).Replace(" ", "-").ToLower();
    return newString;
}

Voici une version très concise

myString = myString.replace(/[^A-Za-z0-9 -]/g, "");

Il y a un moyen beaucoup plus simple avec Regex.

private string FixString(string str)
{
    return string.IsNullOrEmpty(str) ? str : Regex.Replace(str, "[\\D]", "");
}