从字符串中删除特殊字符的最有效方法

我想从字符串中删除所有特殊字符。允许的字符是AZ（大写或小写），数字（0-9），下划线（_）或点号（。）。

我有以下内容，它可以正常工作，但我怀疑（我知道！）它不是很有效：

    public static string RemoveSpecialCharacters(string str)
    {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.Length; i++)
        {
            if ((str[i] >= '0' && str[i] <= '9')
                || (str[i] >= 'A' && str[i] <= 'z'
                    || (str[i] == '.' || str[i] == '_')))
                {
                    sb.Append(str[i]);
                }
        }

        return sb.ToString();
    }

最有效的方法是什么？正则表达式是什么样子，与普通的字符串操作相比如何？

将要清理的字符串会很短，通常在10到30个字符之间。

为什么您认为您的方法效率不高？实际上，这是最有效的方法之一。

您当然应该将字符读入局部变量，或者使用枚举数来减少数组访问的次数：

public static string RemoveSpecialCharacters(this string str) {
   StringBuilder sb = new StringBuilder();
   foreach (char c in str) {
      if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '.' || c == '_') {
         sb.Append(c);
      }
   }
   return sb.ToString();
}

使这种方法有效的一件事是它的伸缩性很好。执行时间将相对于字符串的长度。如果将它用在大字符串上没有令人讨厌的惊喜。

编辑：
我进行了一项快速的性能测试，使用24个字符串运行每个功能一百万次。结果如下：

原始功能：54.5毫秒。
我建议的更改：47.1毫秒。
设置StringBuilder容量的矿井：43.3毫秒。
正则表达式：294.4 ms。

编辑2：我在上面的代码中添加了AZ和az之间的区别。（我重新进行了性能测试，没有明显的区别。）

编辑3：
我测试了lookup + char []解决方案，它运行约13毫秒。

当然，要付出的代价是巨大查找表的初始化并将其保存在内存中。嗯，这不是很多数据，但是对于这样一个微不足道的功能来说却是很多...

private static bool[] _lookup;

static Program() {
   _lookup = new bool[65536];
   for (char c = '0'; c <= '9'; c++) _lookup[c] = true;
   for (char c = 'A'; c <= 'Z'; c++) _lookup[c] = true;
   for (char c = 'a'; c <= 'z'; c++) _lookup[c] = true;
   _lookup['.'] = true;
   _lookup['_'] = true;
}

public static string RemoveSpecialCharacters(string str) {
   char[] buffer = new char[str.Length];
   int index = 0;
   foreach (char c in str) {
      if (_lookup[c]) {
         buffer[index] = c;
         index++;
      }
   }
   return new string(buffer, 0, index);
}

好吧，除非您真的需要从功能中挤出性能，否则，请选择最容易维护和理解的内容。正则表达式如下所示：

为了提高性能，您可以预编译它，也可以告诉它在首次调用时进行编译（后续调用会更快。）

public static string RemoveSpecialCharacters(string str)
{
    return Regex.Replace(str, "[^a-zA-Z0-9_.]+", "", RegexOptions.Compiled);
}

我建议创建一个简单的查找表，您可以在静态构造函数中对其进行初始化，以将任意字符组合设置为有效。这使您可以快速进行一次检查。

编辑

另外，为了提高速度，您需要将StringBuilder的容量初始化为输入字符串的长度。这将避免重新分配。这两种方法共同为您提供速度和灵活性。

另一个编辑

我认为编译器可能会对其进行优化，但是考虑到样式和效率，我建议使用foreach而不是for。

public static string RemoveSpecialCharacters(string str)
{
    char[] buffer = new char[str.Length];
    int idx = 0;

    foreach (char c in str)
    {
        if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z')
            || (c >= 'a' && c <= 'z') || (c == '.') || (c == '_'))
        {
            buffer[idx] = c;
            idx++;
        }
    }

    return new string(buffer, 0, idx);
}

正则表达式如下所示：

public string RemoveSpecialChars(string input)
{
    return Regex.Replace(input, @"[^0-9a-zA-Z\._]", string.Empty);
}

但是，如果性能非常重要，我建议您在选择“正则表达式路径”之前做一些基准测试。

如果您使用的是动态字符列表，则LINQ可能会提供一种更快，更优雅的解决方案：

public static string RemoveSpecialCharacters(string value, char[] specialCharacters)
{
    return new String(value.Except(specialCharacters).ToArray());
}

我将此方法与以前的两种“快速”方法（发行版）进行了比较：

• LukeH的Char数组解决方案-427毫秒
• StringBuilder解决方案-429毫秒
• LINQ（此答案）-98毫秒

请注意，该算法稍作修改-字符以数组形式而不是硬编码形式传入，这可能会稍有影响（即，其他解决方案将具有内部foor循环来检查字符数组）。

如果我使用LINQ where子句切换到硬编码的解决方案，则结果是：

• 字符数组解决方案-7ms
• StringBuilder解决方案-22ms
• LINQ-60毫秒

如果您打算编写更通用的解决方案，而不是硬编码字符列表，则可能值得考虑使用LINQ或改进的方法。LINQ绝对可以为您提供简洁，易读的代码-比Regex还要多。

我不认为您的算法是有效的。它是O（n），每个字符只看一次。除非您在检查值之前就神奇地知道了这些值，否则您将无法获得更好的结果。

但是，我会将您的容量初始化StringBuilder为字符串的初始大小。我猜您认为性能问题来自内存重新分配。

旁注：检查A- z不安全。你包括[，\，]，^，_，和`...

旁注2：为获得额外的效率，请对比较进行排序，以最大程度地减少比较次数。（在最坏的情况下，您正在说的是8个比较，因此，请不要太用心思考。）这种情况随您的预期输入而变化，但是一个示例可能是：

if (str[i] >= '0' && str[i] <= 'z' && 
    (str[i] >= 'a' || str[i] <= '9' ||  (str[i] >= 'A' && str[i] <= 'Z') || 
    str[i] == '_') || str[i] == '.')

旁注3：如果出于任何原因您确实需要快速，那么switch语句可能会更快。编译器应为您创建一个跳转表，仅进行一次比较：

switch (str[i])
{
    case '0':
    case '1':
    .
    .
    .
    case '.':
        sb.Append(str[i]);
        break;
}

StringBuilder sb = new StringBuilder();

for (int i = 0; i < fName.Length; i++)
{
   if (char.IsLetterOrDigit(fName[i]))
    {
       sb.Append(fName[i]);
    }
}

您可以按以下方式使用常规表达式：

return Regex.Replace(strIn, @"[^\w\.@-]", "", RegexOptions.None, TimeSpan.FromSeconds(1.0));

对我来说似乎很好。我唯一要做的改进是StringBuilder使用字符串的长度初始化。

StringBuilder sb = new StringBuilder(str.Length);

我同意此代码示例。唯一不同的是它使它成为字符串类型的扩展方法。这样您就可以在非常简单的行或代码中使用它：

string test = "abc@#$123";
test.RemoveSpecialCharacters();

感谢Guffa的实验。

public static class MethodExtensionHelper
    {
    public static string RemoveSpecialCharacters(this string str)
        {
            StringBuilder sb = new StringBuilder();
            foreach (char c in str)
            {
                if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
                {
                    sb.Append(c);
                }
            }
            return sb.ToString();
        }
}

我将使用带正则表达式的字符串替换来搜索“特殊字符”，并将所有找到的字符替换为空字符串。

我必须为工作做类似的事情，但就我而言，我必须过滤所有不是字母，数字或空格的内容（但您可以根据需要轻松地对其进行修改）。过滤是在JavaScript的客户端完成的，但出于安全原因，我也在服务器端进行了过滤。由于可以预期大多数字符串都是干净的，因此除非我确实需要，否则我将避免复制字符串。这使我可以执行下面的实现，它对于干净的字符串和脏字符串都应具有更好的性能。

public static string EnsureOnlyLetterDigitOrWhiteSpace(string input)
{
    StringBuilder cleanedInput = null;
    for (var i = 0; i < input.Length; ++i)
    {
        var currentChar = input[i];
        var charIsValid = char.IsLetterOrDigit(currentChar) || char.IsWhiteSpace(currentChar);

        if (charIsValid)
        {
            if(cleanedInput != null)
                cleanedInput.Append(currentChar);
        }
        else
        {
            if (cleanedInput != null) continue;
            cleanedInput = new StringBuilder();
            if (i > 0)
                cleanedInput.Append(input.Substring(0, i));
        }
    }

    return cleanedInput == null ? input : cleanedInput.ToString();
}

对于S＆G而言，Linq可以通过以下方式实现：

var original = "(*^%foo)(@)&^@#><>?:\":';=-+_";
var valid = new char[] { 
    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 
    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 
    'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 
    'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6', '7', '8', 
    '9', '0', '.', '_' };
var result = string.Join("",
    (from x in original.ToCharArray() 
     where valid.Contains(x) select x.ToString())
        .ToArray());

但是，我认为这不是最有效的方法。

public string RemoveSpecial(string evalstr)
{
StringBuilder finalstr = new StringBuilder();
            foreach(char c in evalstr){
            int charassci = Convert.ToInt16(c);
            if (!(charassci >= 33 && charassci <= 47))// special char ???
             finalstr.append(c);
            }
return finalstr.ToString();
}

用：

s.erase(std::remove_if(s.begin(), s.end(), my_predicate), s.end());

bool my_predicate(char c)
{
 return !(isalpha(c) || c=='_' || c==' '); // depending on you definition of special characters
}

然后您会得到一个干净的字符串s。

erase()会删除所有特殊字符，并且可以通过该my_predicate()功能进行高度自定义。

HashSet为O（1）
不确定它是否比现有比较快

private static HashSet<char> ValidChars = new HashSet<char>() { 'a', 'b', 'c', 'A', 'B', 'C', '1', '2', '3', '_' };
public static string RemoveSpecialCharacters(string str)
{
    StringBuilder sb = new StringBuilder(str.Length / 2);
    foreach (char c in str)
    {
        if (ValidChars.Contains(c)) sb.Append(c);
    }
    return sb.ToString();
}

我进行了测试，而且速度不超过公认的答案。
我将保留它，好像您需要一组可配置的字符一样，这​​将是一个很好的解决方案。

我想知道基于Regex的替换（可能是编译的）是否更快。必须测试是否有人发现它慢了大约5倍。

除此之外，您应该使用预期的长度初始化StringBuilder，以便中间字符串在增长时不必复制。

一个好的数字是原始字符串的长度，或者稍微短一些（取决于函数输入的性质）。

最后，您可以使用查找表（范围为0..127）来确定是否接受字符。

以下代码具有以下输出（结论是我们还可以节省一些内存资源，以较小的数组分配数组）：

lookup = new bool[123];

for (var c = '0'; c <= '9'; c++)
{
    lookup[c] = true; System.Diagnostics.Debug.WriteLine((int)c + ": " + (char)c);
}

for (var c = 'A'; c <= 'Z'; c++)
{
    lookup[c] = true; System.Diagnostics.Debug.WriteLine((int)c + ": " + (char)c);
}

for (var c = 'a'; c <= 'z'; c++)
{
    lookup[c] = true; System.Diagnostics.Debug.WriteLine((int)c + ": " + (char)c);
}

48: 0  
49: 1  
50: 2  
51: 3  
52: 4  
53: 5  
54: 6  
55: 7  
56: 8  
57: 9  
65: A  
66: B  
67: C  
68: D  
69: E  
70: F  
71: G  
72: H  
73: I  
74: J  
75: K  
76: L  
77: M  
78: N  
79: O  
80: P  
81: Q  
82: R  
83: S  
84: T  
85: U  
86: V  
87: W  
88: X  
89: Y  
90: Z  
97: a  
98: b  
99: c  
100: d  
101: e  
102: f  
103: g  
104: h  
105: i  
106: j  
107: k  
108: l  
109: m  
110: n  
111: o  
112: p  
113: q  
114: r  
115: s  
116: t  
117: u  
118: v  
119: w  
120: x  
121: y  
122: z  

您还可以添加以下代码行以支持俄语语言环境（数组大小为1104）：

for (var c = 'А'; c <= 'Я'; c++)
{
    lookup[c] = true; System.Diagnostics.Debug.WriteLine((int)c + ": " + (char)c);
}

for (var c = 'а'; c <= 'я'; c++)
{
    lookup[c] = true; System.Diagnostics.Debug.WriteLine((int)c + ": " + (char)c);
}

我不确定这是最有效的方法，但对我有用

 Public Function RemoverTildes(stIn As String) As String
    Dim stFormD As String = stIn.Normalize(NormalizationForm.FormD)
    Dim sb As New StringBuilder()

    For ich As Integer = 0 To stFormD.Length - 1
        Dim uc As UnicodeCategory = CharUnicodeInfo.GetUnicodeCategory(stFormD(ich))
        If uc <> UnicodeCategory.NonSpacingMark Then
            sb.Append(stFormD(ich))
        End If
    Next
    Return (sb.ToString().Normalize(NormalizationForm.FormC))
End Function

这里有很多建议的解决方案，有些解决方案比其他解决方案更有效，但可能不太可读。这可能不是最高效的，但肯定可以在大多数情况下使用，并且利用Linq十分简洁易读：

string stringToclean = "This is a test.  Do not try this at home; you might get hurt. Don't believe it?";

var validPunctuation = new HashSet<char>(". -");

var cleanedVersion = new String(stringToclean.Where(x => (x >= 'A' && x <= 'Z') || (x >= 'a' && x <= 'z') || validPunctuation.Contains(x)).ToArray());

var cleanedLowercaseVersion = new String(stringToclean.ToLower().Where(x => (x >= 'a' && x <= 'z') || validPunctuation.Contains(x)).ToArray());

public static string RemoveSpecialCharacters(string str){
    return str.replaceAll("[^A-Za-z0-9_\\\\.]", "");
}

public static string RemoveAllSpecialCharacters(this string text) {
  if (string.IsNullOrEmpty(text))
    return text;

  string result = Regex.Replace(text, "[:!@#$%^&*()}{|\":?><\\[\\]\\;'/.,~]", " ");
  return result;
}

如果您担心速度，请使用指针来编辑现有字符串。您可以固定字符串并获得指向它的指针，然后在每个字符上运行for循环，并用替换字符覆盖每个无效字符。这将是非常高效的，并且不需要分配任何新的字符串内存。您还需要使用unsafe选项编译模块，并在方法标题中添加“ unsafe”修饰符以使用指针。

static void Main(string[] args)
{
    string str = "string!$%with^&*invalid!!characters";
    Console.WriteLine( str ); //print original string
    FixMyString( str, ' ' );
    Console.WriteLine( str ); //print string again to verify that it has been modified
    Console.ReadLine(); //pause to leave command prompt open
}


public static unsafe void FixMyString( string str, char replacement_char )
{
    fixed (char* p_str = str)
    {
        char* c = p_str; //temp pointer, since p_str is read-only
        for (int i = 0; i < str.Length; i++, c++) //loop through each character in string, advancing the character pointer as well
            if (!IsValidChar(*c)) //check whether the current character is invalid
                (*c) = replacement_char; //overwrite character in existing string with replacement character
    }
}

public static bool IsValidChar( char c )
{
    return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '.' || c == '_');
    //return char.IsLetterOrDigit( c ) || c == '.' || c == '_'; //this may work as well
}