net - regex matches c#

¿Cuál es la forma más rápida de extraer un número de 5 dígitos de una cadena en c#

Question

¿Cuál es la forma más rápida de extraer un número de 5 dígitos de una cadena en c #.

Tengo

string.Join(null, System.Text.RegularExpressions.Regex.Split(expression, "[^//d]"));

¿Cualquier otro?

Answer 1

¿Quiere decir convertir una cadena a un número? ¿O encuentra la primera cadena de 5 dígitos y luego la convierte en un número? De cualquier manera, probablemente usará decimal.Parse o int.Parse.

Soy de la opinión de que las expresiones regulares son el enfoque equivocado. Un enfoque más eficiente sería simplemente caminar a través de la cuerda buscando un dígito, y luego avanzar 4 caracteres y ver si son todos dígitos. Si lo son, tienes tu subcadena. No es tan robusto, no, pero tampoco tiene la sobrecarga.

Answer 2

El enfoque de expresiones regulares es probablemente el más rápido de implementar, pero no el más rápido de ejecutar. Comparé una solución de expresiones regulares simple con el siguiente código de búsqueda manual y encontré que el código de búsqueda manual es ~ 2x-2.5x más rápido para cadenas de entrada grandes y hasta 4 veces más rápido para cadenas pequeñas:

static string Search(string expression)
{
  int run = 0;
  for (int i = 0; i < expression.Length; i++)
  {
    char c = expression[i];
    if (Char.IsDigit(c))
      run++;
    else if (run == 5)
      return expression.Substring(i - run, run);
    else
      run = 0;
  }
  return null;
}
const string pattern = @"/d{5}";
static string NotCached(string expression)
{
  return Regex.Match(expression, pattern, RegexOptions.Compiled).Value;
}

static Regex regex = new Regex(pattern, RegexOptions.Compiled);
static string Cached(string expression)
{
  return regex.Match(expression).Value;
}

Resultados para una cadena de ~ 50 caracteres con una cadena de 5 dígitos en el medio, más de 10 ^ 6 iteraciones, latencia por llamada en microsegundos (el número más pequeño es más rápido):

Búsqueda simple: 0.648396us

Regex en caché: 2.1414645us

Regex no en caché: 3.070116us

Resultados para una cadena ~ 40K con una cadena de 5 dígitos en el medio a lo largo de 10 ^ 4 iteraciones, latencia por llamada en microsegundos (el número más pequeño es más rápido):

Búsqueda simple: 423.801us

Regex en caché: 1155.3948us

Regex no en caché: 1220.625us

Un poco sorprendente: esperaba que Regex, compilado para IL, fuera comparable a la búsqueda manual, al menos para cadenas muy grandes.

Answer 3

Esto podría ser más rápido ...

public static string DigitsOnly(string inVal)
        {
            char[] newPhon = new char[inVal.Length];
            int i = 0;
            foreach (char c in inVal)
                if (c.CompareTo(''0'') > 0 && c.CompareTo(''9'') < 0)
                    newPhon[i++] = c;
            return newPhon.ToString();
        }

si quiere limitarlo a un máximo de cinco dígitos, entonces

public static string DigitsOnly(string inVal)
        {
            char[] newPhon = new char[inVal.Length];
            int i = 0;
            foreach (char c in inVal)
                if (c.CompareTo(''0'') > 0 && c.CompareTo(''9'') < 0 && i < 5)
                    newPhon[i++] = c;
            return newPhon.ToString();
        }

Answer 4

No use una expresión regular en absoluto. Es mucho más poderoso de lo que necesita, y es probable que ese poder afecte el rendimiento.

Si puede dar más detalles de lo que necesita hacer, podemos escribir el código apropiado ... (Los casos de prueba serían ideales).

Answer 5

Para la mayoría de las cadenas, un método de fuerza bruta será más rápido que un RegEx.

Un ejemplo bastante agradable sería:

string strIWantNumFrom = "qweqwe23qeeq3eqqew9qwer0q";

int num = int.Parse(
    string.Join( null, (
        from c in strIWantNumFrom.ToCharArray()
        where c == ''1'' || c == ''2'' || c == ''3'' || c == ''4'' || c == ''5'' ||
            c == ''6'' || c == ''7'' || c == ''8'' || c == ''9'' || c == ''0''
        select c.ToString()
    ).ToArray() ) );

Sin duda hay formas mucho más rápidas y muchas optimizaciones que dependen del formato exacto de su cadena.

Answer 6

Si los números existen con otros caracteres, las expresiones regulares son una buena solución.

EG: ([0-9] {5})

coincidirá - asdfkki12345afdkjsdl, 12345adfaksk o akdkfa12345

Answer 7

Si tiene un caso de prueba simple como "12345" o incluso "12345abcd", no use expresiones regulares en absoluto. No son conocidos por su velocidad.

Answer 8

Use una expresión regular (/ d {5}) para encontrar la (s) ocurrencia (s) del número de 5 dígitos en la cadena y use int.Parse o decimal.Parque en la (s) coincidencia (es).

En el caso donde solo hay un número en el text .

int? value = null;
string pat = @"/d{5}"
Regex r = new Regex(pat);
Match m = r.Match(text);
if (m.Success)
{
   value = int.Parse(m.Value);
}