La forma más eficiente de eliminar caracteres especiales de la cadena

Quiero eliminar todos los caracteres especiales de una cadena. Los caracteres permitidos son AZ (mayúsculas o minúsculas), números (0-9), guión bajo (_) o el signo de punto (.).

Tengo lo siguiente, funciona pero sospecho (¡lo sé!) No es muy eficiente:

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

¿Cuál es la forma más eficiente de hacer esto? ¿Cómo se vería una expresión regular y cómo se compara con la manipulación normal de cadenas?

Las cadenas que se limpiarán serán bastante cortas, generalmente de entre 10 y 30 caracteres de longitud.

¿Por qué crees que tu método no es eficiente? En realidad, es una de las formas más eficientes en que puede hacerlo.

Por supuesto, debe leer el carácter en una variable local o usar un enumerador para reducir el número de accesos a la matriz:

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

Una cosa que hace que un método como este sea eficiente es que escala bien. El tiempo de ejecución será relativo a la longitud de la cadena. No hay sorpresas desagradables si lo usarías en una cadena grande.

Editar:
Hice una prueba de rendimiento rápida, ejecutando cada función un millón de veces con una cadena de 24 caracteres. Estos son los resultados:

Función original: 54,5 ms.
Mi cambio sugerido: 47.1 ms.
Mina con capacidad de StringBuilder configurada: 43.3 ms.
Expresión regular: 294,4 ms.

Edición 2: agregué la distinción entre AZ y az en el código anterior. (Volví a realizar la prueba de rendimiento y no hay una diferencia notable).

Edición 3:
probé la solución lookup + char [], y se ejecuta en unos 13 ms.

El precio a pagar es, por supuesto, la inicialización de la gran tabla de búsqueda y mantenerla en la memoria. Bueno, no son tantos datos, pero son muchos para una función tan trivial ...

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

Bueno, a menos que realmente necesite exprimir el rendimiento de su función, solo elija lo que sea más fácil de mantener y comprender. Una expresión regular se vería así:

Para un rendimiento adicional, puede precompilarlo o simplemente decirle que se compile en la primera llamada (las llamadas posteriores serán más rápidas).

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

Sugiero crear una tabla de búsqueda simple, que puede inicializar en el constructor estático para establecer cualquier combinación de caracteres como válida. Esto le permite hacer una verificación rápida y única.

editar

Además, para la velocidad, querrás inicializar la capacidad de tu StringBuilder a la longitud de tu cadena de entrada. Esto evitará reasignaciones. Estos dos métodos juntos le darán velocidad y flexibilidad.

otra edición

Creo que el compilador podría optimizarlo, pero por cuestiones de estilo y eficiencia, recomiendo foreach en lugar de por.

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

Una expresión regular se verá así:

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

Pero si el rendimiento es muy importante, le recomiendo que haga algunos puntos de referencia antes de seleccionar la "ruta de expresión regular" ...

Si está utilizando una lista dinámica de caracteres, LINQ puede ofrecer una solución mucho más rápida y elegante:

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

Comparé este enfoque con dos de los enfoques "rápidos" anteriores (compilación de lanzamiento):

• Solución de matriz de char por LukeH - 427 ms
• Solución StringBuilder - 429 ms
• LINQ (esta respuesta) - 98 ms

Tenga en cuenta que el algoritmo se modifica ligeramente: los caracteres se pasan como una matriz en lugar de codificados, lo que podría tener un impacto leve en las cosas (es decir, / las otras soluciones tendrían un bucle interno para verificar la matriz de caracteres).

Si cambio a una solución codificada con una cláusula where de LINQ, los resultados son:

• Solución de matriz de char - 7ms
• Solución StringBuilder - 22ms
• LINQ - 60 ms

Puede valer la pena mirar LINQ o un enfoque modificado si planea escribir una solución más genérica, en lugar de codificar la lista de caracteres. LINQ definitivamente le brinda un código conciso y altamente legible, incluso más que Regex.

No estoy convencido de que su algoritmo sea otra cosa que eficiente. Es O (n) y solo mira a cada personaje una vez. No obtendrá nada mejor que eso a menos que conozca mágicamente los valores antes de verificarlos.

Sin embargo, inicializaría la capacidad de tu StringBuilderal tamaño inicial de la cadena. Supongo que su problema de rendimiento percibido proviene de la reasignación de memoria.

Nota al margen: Comprobación A: zno es seguro. Estás incluyendo [, \, ], ^, _, y `...

Nota al margen 2: Para ese bit extra de eficiencia, coloque las comparaciones en un orden para minimizar el número de comparaciones. (En el peor de los casos, estás hablando de 8 comparaciones, así que no pienses demasiado). Esto cambia con tu aporte esperado, pero un ejemplo podría ser:

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

Nota al margen 3: si por alguna razón REALMENTE necesita que esto sea rápido, una declaración de cambio puede ser más rápida. El compilador debe crear una tabla de salto para usted, lo que resulta en una sola comparación:

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

Puede usar la expresión regular de la siguiente manera:

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

Me parece bien La única mejora que haría es inicializar StringBuildercon la longitud de la cadena.

StringBuilder sb = new StringBuilder(str.Length);

Estoy de acuerdo con este ejemplo de código. Lo único diferente es que lo convierto en Método de extensión de tipo de cadena. Para que pueda usarlo en una línea o código muy simple:

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

Gracias a Guffa por tu experimento.

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

Usaría un reemplazo de cadena con una expresión regular buscando "caracteres especiales", reemplazando todos los caracteres encontrados con una cadena vacía.

Tenía que hacer algo similar para el trabajo, pero en mi caso tuve que filtrar todo lo que no sea una letra, un número o un espacio en blanco (pero podría modificarlo fácilmente según sus necesidades). El filtrado se realiza del lado del cliente en JavaScript, pero por razones de seguridad también estoy haciendo el filtrado del lado del servidor. Como puedo esperar que la mayoría de las cadenas estén limpias, me gustaría evitar copiar la cadena a menos que realmente lo necesite. Esto me permite la implementación a continuación, que debería funcionar mejor tanto para cadenas limpias como sucias.

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

Para S & G's, forma 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());

Sin embargo, no creo que esta sea la forma más eficiente.

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

Utilizar:

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
}

Y obtendrás una cuerda limpia s.

erase()lo despojará de todos los caracteres especiales y es altamente personalizable con la my_predicate()función.

HashSet es O (1)
No estoy seguro si es más rápido que la comparación existente

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

Probé y esto no más rápido que la respuesta aceptada.
Lo dejaré como si necesitaras un conjunto de caracteres configurable, esta sería una buena solución.

Me pregunto si un reemplazo basado en Regex (posiblemente compilado) es más rápido. Tendría que probar que alguien ha encontrado que esto es ~ 5 veces más lento.

Aparte de eso, debe inicializar el StringBuilder con una longitud esperada, para que la cadena intermedia no tenga que copiarse mientras crece.

Un buen número es la longitud de la cadena original, o algo ligeramente más bajo (dependiendo de la naturaleza de las entradas de funciones).

Finalmente, puede usar una tabla de búsqueda (en el rango 0..127) para averiguar si un personaje debe ser aceptado.

El siguiente código tiene el siguiente resultado (la conclusión es que también podemos guardar algunos recursos de memoria asignando un tamaño de matriz más pequeño):

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  

También puede agregar las siguientes líneas de código para admitir la configuración regional rusa (el tamaño de la matriz será 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);
}

No estoy seguro de que sea la forma más eficiente, pero funciona para mí.

 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

Aquí hay muchas soluciones propuestas, algunas más eficientes que otras, pero quizás no muy legibles. Aquí hay uno que puede no ser el más eficiente, pero ciertamente utilizable para la mayoría de las situaciones, y es bastante conciso y legible, aprovechando 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;
}

Si le preocupa la velocidad, use punteros para editar la cadena existente. Puede anclar la cadena y obtener un puntero, luego ejecutar un bucle for sobre cada carácter, sobrescribiendo cada carácter no válido con un carácter de reemplazo. Sería extremadamente eficiente y no requeriría asignar ninguna nueva memoria de cadena. También necesitaría compilar su módulo con la opción insegura y agregar el modificador "inseguro" al encabezado de su método para usar punteros.

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
}