Самый эффективный способ удалить специальные символы из строки

Я хочу удалить все специальные символы из строки. Допустимые символы: 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 мс

Редактировать 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 - 427 мс
• Решение StringBuilder - 429 мс
• LINQ (этот ответ) - 98 мс

Обратите внимание, что алгоритм немного изменен - ​​символы передаются в виде массива, а не жестко закодированы, что может немного повлиять на вещи (т. Е. / Другие решения будут иметь внутренний цикл foor для проверки массива символов).

Если я перейду к жестко запрограммированному решению, используя предложение LINQ where, то получится следующее:

• Решение с массивом символов - 7мс
• Решение StringBuilder - 22 мс
• 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();
        }
}

Я бы использовал String Replace с Regular Expression для поиска «специальных символов», заменяя все найденные символы пустой строкой.

Я должен был сделать что-то подобное для работы, но в моем случае мне пришлось отфильтровать все, что не является буквой, цифрой или пробелом (но вы могли легко изменить это в соответствии с вашими потребностями). Фильтрация выполняется на стороне клиента в 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-ified способ:

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

Я проверил, и это не быстрее, чем принятый ответ.
Я оставлю это так, как будто вам нужен настраиваемый набор символов, это было бы хорошим решением.

Интересно, быстрее ли будет замена на основе регулярных выражений (возможно, скомпилированная). Придется проверить, что кто-то обнаружил, что это примерно в 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
}