Wie entferne ich alle nicht alphanumerischen Zeichen mit Ausnahme des Bindestrichs aus einer Zeichenfolge?

Wie entferne ich alle nicht alphanumerischen Zeichen aus einer Zeichenfolge mit Ausnahme von Bindestrich- und Leerzeichen?

Durch [^a-zA-Z0-9 -]eine leere Zeichenfolge ersetzen .

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

Ich hätte RegEx verwenden können, sie können eine elegante Lösung bieten, aber sie können Leistungsprobleme verursachen. Hier ist eine Lösung

char[] arr = str.ToCharArray();

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

Bei Verwendung des kompakten Frameworks (das nicht über FindAll verfügt)

Ersetzen Sie FindAll durch ¹

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

str = new string(arr);

¹ Kommentar von ShawnFeatherly

Du kannst es versuchen:

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

Wo sist deine Schnur?

Verwenden von System.Linq

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

Der reguläre Ausdruck ist [^\w\s\-]*:

\sist besser als space ( ) zu verwenden, da der Text möglicherweise eine Registerkarte enthält.

Basierend auf der Antwort auf diese Frage habe ich eine statische Klasse erstellt und diese hinzugefügt. Dachte, es könnte für einige Leute nützlich sein.

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

Dann können die Methoden verwendet werden als:

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

Willst du etwas schnelles?

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

Auf diese Weise können Sie angeben, welche Zeichen Sie ebenfalls zulassen möchten.

Hier ist eine nicht regex Heap Allocation freundliche schnelle Lösung, nach der ich gesucht habe.

Unsichere Ausgabe.

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

Und für diejenigen, die nicht unsicher verwenden wollen oder dem String-Länge-Hack nicht vertrauen.

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

Ich habe eine andere Lösung gefunden, indem ich die Steuerzeichen entfernt habe , was mein ursprüngliches Problem war.

Es ist besser, als alle "besonderen, aber guten" Zeichen in eine Liste aufzunehmen

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

es ist einfacher, also denke ich es ist besser!

Hier ist eine Erweiterungsmethode, bei der @ata answer als Inspiration verwendet wird.

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

oder wenn Sie zusätzliche Zeichen außer Bindestrich benötigen ...

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

Ich verwende hier eine Variation einer der Antworten. Ich möchte Leerzeichen durch "-" ersetzen, damit es SEO-freundlich ist und auch Kleinbuchstaben enthält. Auch nicht auf system.web aus meiner Serviceschicht verweisen.

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

Hier ist eine sehr knappe Version

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

Mit Regex gibt es einen viel einfacheren Weg.

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