Come rimuovo tutti i caratteri non alfanumerici da una stringa tranne il trattino?

Come rimuovo tutti i caratteri non alfanumerici da una stringa tranne i caratteri trattino e spazio?

Sostituisci [^a-zA-Z0-9 -]con una stringa vuota.

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

Avrei potuto usare RegEx, possono fornire una soluzione elegante ma possono causare problemi di performane. Ecco una soluzione

char[] arr = str.ToCharArray();

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

Quando si utilizza il framework compatto (che non ha FindAll)

Sostituisci FindAll con ¹

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

str = new string(arr);

¹ commento di ShawnFeatherly

Puoi provare:

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

Dov'è la stua stringa.

Utilizzando System.Linq

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

Il regex è [^\w\s\-]*:

\sè meglio usare al posto dello spazio ( ), perché potrebbe esserci una scheda nel testo.

Sulla base della risposta a questa domanda, ho creato una classe statica e le ho aggiunte. Ho pensato che potesse essere utile per alcune persone.

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, "");
    }
}

Quindi i metodi possono essere usati come:

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

Vuoi qualcosa di veloce?

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)));
    }
}

Ciò ti consentirà di specificare anche quali caratteri vuoi consentire.

Ecco una soluzione rapida per l'allocazione di heap non regex che era quello che stavo cercando.

Edizione non sicura.

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';
    }
}

E per coloro che non vogliono usare non sicuri o non si fidano dell'hack della lunghezza della stringa.

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);
}

Ho fatto una soluzione diversa, eliminando i personaggi di controllo , che era il mio problema originale.

È meglio che mettere in una lista tutti i caratteri "speciali ma buoni"

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

è più semplice, quindi penso che sia meglio!

Ecco un metodo di estensione che utilizza @ata answer come ispirazione.

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

o se hai bisogno di caratteri aggiuntivi diversi dal trattino ...

"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);
    }
}

Uso una variante di una delle risposte qui. Voglio sostituire gli spazi con "-" in modo che sia SEO friendly e anche in minuscolo. Inoltre, non fare riferimento a system.web dal mio livello di servizi.

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;
}

Ecco una versione molto concisa

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

C'è un modo molto più semplice con Regex.

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