test - regexp javascript

¿Por qué esta expresión regular es más rápida?

Question

Estoy escribiendo un tipo de cliente Telnet en C # y parte de lo que tengo que analizar son las secuencias de escape ANSI / VT100, específicamente, solo aquellas usadas para el color y el formato (detallado aquí ).

Un método que tengo es uno para encontrar todos los códigos y eliminarlos, por lo que puedo renderizar el texto sin ningún formato si es necesario:

    
public static string StripStringFormating(string formattedString)
{
    if (rTest.IsMatch(formattedString))
        return rTest.Replace(formattedString, string.Empty);
    else
        return formattedString;
}

Soy nuevo en las expresiones regulares y me sugirieron usar esto:

static Regex rText = new Regex(@"/e/[[/d;]+m", RegexOptions.Compiled);

Sin embargo, esto falló si el código de escape estaba incompleto debido a un error en el servidor. Entonces, esto fue sugerido, pero mi amigo me advirtió que podría ser más lento (este también coincide con otra condición (z) que podría encontrar más adelante):

static Regex rTest = 
              new Regex(@"(/e(/[([/d;]*[mz]?))?)?", RegexOptions.Compiled);

Esto no solo funcionó, sino que de hecho fue más rápido y redujo el impacto en la representación de mi texto. ¿Puede alguien explicarle a un novato de expresiones regulares, por qué? :)

Answer 1

La razón por la cual # 1 es más lento es que [/ d;] + es un cuantificador codicioso. ¿Usando +? o *? va a hacer una cuantificación perezosa. Ver MSDN - Cuantificadores para más información.

Es posible que desee intentar:

"(/e/[(/d{1,2};)*?[mz]?)?"

Eso puede ser más rápido para ti.

Answer 2

¿Realmente quieres ejecutar la expresión regular dos veces? Sin haber verificado (mal mi), hubiera pensado que esto funcionaría bien:

public static string StripStringFormating(string formattedString)
{    
    return rTest.Replace(formattedString, string.Empty);
}

Si lo hace, deberías verlo correr ~ dos veces más rápido ...

Answer 3

No estoy seguro si esto ayudará con lo que está trabajando, pero hace mucho tiempo escribí una expresión regular para analizar los archivos gráficos ANSI.

(?s)(?:/e/[(?:(/d+);?)*([A-Za-z])(.*?))(?=/e/[|/z)

Devolverá cada código y el texto asociado a él.

Cadena de entrada:

<ESC>[1;32mThis is bright green.<ESC>[0m This is the default color.

Resultados:

[ [1, 32], m, This is bright green.]
[0, m, This is the default color.]

Answer 4

Sin hacer un análisis detallado, supongo que es más rápido debido a los signos de interrogación. Éstos permiten que la expresión regular sea "floja" y se detiene tan pronto como tienen suficiente para coincidir, en lugar de verificar si el resto de la entrada coincide.

Sin embargo, no estoy del todo contento con esta respuesta, porque esto se aplica principalmente a los signos de interrogación después de * o +. Si estuviera más familiarizado con la entrada, podría tener más sentido para mí.

(Además, para el formato del código, puede seleccionar todo su código y presionar Ctrl + K para que agregue los cuatro espacios requeridos).