regular - regex c# ejemplos

¿Necesita realizar una búsqueda con comodines(*,?, Etc.) en una cadena usando Regex

Question

Necesito realizar una búsqueda con comodines ( * , ? , Etc.) en una cadena. Esto es lo que he hecho:

string input = "Message";
string pattern = "d*";
Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);

if (regex.IsMatch(input))
{
    MessageBox.Show("Found");
}
else
{
    MessageBox.Show("Not Found");
}

Con el código anterior, el bloque "Encontrado" está pegando pero en realidad ¡no debería!

Si mi patrón es "e *", solo debe "Buscarse".

Mi comprensión o requisito es d * search, debería encontrar el texto que contiene "d" seguido de cualquier carácter.

¿Debo cambiar mi patrón como "d. *" Y "e. *"? ¿Hay algún soporte en .NET para Wild Card que internamente lo hace mientras usa la clase Regex?

Answer 1

Creo que @Dmitri tiene una buena solución en Matching Strings con wildcard https://.com/a/30300521/1726296

Basado en su solución, he creado dos métodos de extensión. (el crédito va para él)

Puede ser útil.

public static String WildCardToRegular(this String value)
{
        return "^" + Regex.Escape(value).Replace("//?", ".").Replace("//*", ".*") + "$";
}

public static bool WildCardMatch(this String value,string pattern,bool ignoreCase = true)
{
        if (ignoreCase)
            return Regex.IsMatch(value, WildCardToRegular(pattern), RegexOptions.IgnoreCase);

        return Regex.IsMatch(value, WildCardToRegular(pattern));
}

Uso:

string pattern = "file.*";

var isMatched = "file.doc".WildCardMatch(pattern)

o

string xlsxFile = "file.xlsx"
var isMatched = xlsxFile.WildCardMatch(pattern)

Answer 2

De http://www.codeproject.com/KB/recipes/wildcardtoregex.aspx :

public static string WildcardToRegex(string pattern)
{
    return "^" + Regex.Escape(pattern)
                      .Replace(@"/*", ".*")
                      .Replace(@"/?", ".")
               + "$";
}

Entonces algo como foo*.xls? se transformará en ^foo.*/.xls.$ .

Answer 3

Debe escapar símbolos Regex especiales en el patrón de entrada de caracteres comodín (por ejemplo, el patrón *.txt será equivalente a ^.*/.txt$ ). Por lo tanto, las barras, los tirantes y muchos símbolos especiales deben reemplazarse con @"/" + s , donde s - símbolo Regex especial

Answer 4

Es posible que desee utilizar WildcardPattern del ensamblado System.Management.Automation . Vea mi respuesta here .

Answer 5

La formulación de expresión regular correcta de la expresión glob d* es ^d , lo que significa que coincide con cualquier cosa que comience con d .

    string input = "Message";
    string pattern = @"^d";
    Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);

(El @coting no es necesario en este caso, pero es una buena práctica, ya que muchas expresiones regulares usan escapes de barra invertida que deben dejarse en blanco, y también indica al lector que esta cadena es especial).

Answer 6

Necesita convertir su expresión de comodín en una expresión regular. Por ejemplo:

    private bool WildcardMatch(String s, String wildcard, bool case_sensitive)
    {
        // Replace the * with an .* and the ? with a dot. Put ^ at the
        // beginning and a $ at the end
        String pattern = "^" + Regex.Escape(wildcard).Replace(@"/*", ".*").Replace(@"/?", ".") + "$";

        // Now, run the Regex as you already know
        Regex regex;
        if(case_sensitive)
            regex = new Regex(pattern);
        else
            regex = new Regex(pattern, RegexOptions.IgnoreCase);

        return(regex.IsMatch(s));
    } 

Answer 7

Puede hacer un comodín simple sin RegEx utilizando una función de Visual Basic llamada LikeString.

using Microsoft.VisualBasic;
using Microsoft.VisualBasic.CompilerServices;

if (Operators.LikeString("This is just a test", "*just*", CompareMethod.Text))
{
  Console.WriteLine("This matched!");
}

Si usa CompareMethod.Text , comparará las mayúsculas y minúsculas. Para la comparación de mayúsculas y minúsculas, puede usar CompareMethod.Binary .

Más información aquí: http://www.henrikbrinch.dk/Blog/2012/02/14/Wildcard-matching-in-C

MSDN: http://msdn.microsoft.com/en-us/library/microsoft.visualbasic.compilerservices.operators.likestring%28v=vs.100%29.ASPX

Answer 8

Todo el código superior no es correcto hasta el final.

Esto se debe a que al buscar zz * foo * o zz * no obtendrá los resultados correctos.

Y si busca "abcd *" en "abcd" en TotalCommander, encontrará un archivo abcd para que todo el código superior sea incorrecto.

Aquí está el código correcto.

public string WildcardToRegex(string pattern)
{             
    string result= Regex.Escape(pattern).
        Replace(@"/*", ".+?").
        Replace(@"/?", "."); 

    if (result.EndsWith(".+?"))
    {
        result = result.Remove(result.Length - 3, 3);
        result += ".*";
    }

    return result;
}

Answer 9

Windows y * nux tratan los comodines de forma diferente. * ? y . son procesados ​​de una manera muy compleja por Windows, su presencia o posición cambiaría el significado de otro. Mientras que * nux lo mantiene simple, todo lo que hace es solo una coincidencia de patrón simple. Además de eso, ? coincide Windows ? para 0 o 1 caracteres, Linux lo compara exactamente con 1 caracteres.

No encontré documentos autorizados sobre este tema, aquí está mi conclusión basada en los días de pruebas en Windows 8 / XP (línea de comando, el comando dir es específico, y el método Directory.GetFiles usa las mismas reglas también) y Ubuntu Servidor 12.04.1 (comando ls ). Hice funcionar decenas de casos comunes y poco comunes, aunque también hay muchos casos fallidos.

La respuesta actual de Gabe, funciona como * nux. Si también desea un estilo de Windows, y está dispuesto a aceptar la imperfección, aquí está:

    /// <summary>
    /// <para>Tests if a file name matches the given wildcard pattern, uses the same rule as shell commands.</para>
    /// </summary>
    /// <param name="fileName">The file name to test, without folder.</param>
    /// <param name="pattern">A wildcard pattern which can use char * to match any amount of characters; or char ? to match one character.</param>
    /// <param name="unixStyle">If true, use the *nix style wildcard rules; otherwise use windows style rules.</param>
    /// <returns>true if the file name matches the pattern, false otherwise.</returns>
    public static bool MatchesWildcard(this string fileName, string pattern, bool unixStyle)
    {
        if (fileName == null)
            throw new ArgumentNullException("fileName");

        if (pattern == null)
            throw new ArgumentNullException("pattern");

        if (unixStyle)
            return WildcardMatchesUnixStyle(pattern, fileName);

        return WildcardMatchesWindowsStyle(fileName, pattern);
    }

    private static bool WildcardMatchesWindowsStyle(string fileName, string pattern)
    {
        var dotdot = pattern.IndexOf("..", StringComparison.Ordinal);
        if (dotdot >= 0)
        {
            for (var i = dotdot; i < pattern.Length; i++)
                if (pattern[i] != ''.'')
                    return false;
        }

        var normalized = Regex.Replace(pattern, @"/.+$", "");
        var endsWithDot = normalized.Length != pattern.Length;

        var endWeight = 0;
        if (endsWithDot)
        {
            var lastNonWildcard = normalized.Length - 1;
            for (; lastNonWildcard >= 0; lastNonWildcard--)
            {
                var c = normalized[lastNonWildcard];
                if (c == ''*'')
                    endWeight += short.MaxValue;
                else if (c == ''?'')
                    endWeight += 1;
                else
                    break;
            }

            if (endWeight > 0)
                normalized = normalized.Substring(0, lastNonWildcard + 1);
        }

        var endsWithWildcardDot = endWeight > 0;
        var endsWithDotWildcardDot = endsWithWildcardDot && normalized.EndsWith(".");
        if (endsWithDotWildcardDot)
            normalized = normalized.Substring(0, normalized.Length - 1);

        normalized = Regex.Replace(normalized, @"(?!^)(/./*)+$", @".*");

        var escaped = Regex.Escape(normalized);
        string head, tail;

        if (endsWithDotWildcardDot)
        {
            head = "^" + escaped;
            tail = @"(/.[^.]{0," + endWeight + "})?$";
        }
        else if (endsWithWildcardDot)
        {
            head = "^" + escaped;
            tail = "[^.]{0," + endWeight + "}$";
        }
        else
        {
            head = "^" + escaped;
            tail = "$";
        }

        if (head.EndsWith(@"/./*") && head.Length > 5)
        {
            head = head.Substring(0, head.Length - 4);
            tail = @"(/..*)?" + tail;
        }

        var regex = head.Replace(@"/*", ".*").Replace(@"/?", "[^.]?") + tail;
        return Regex.IsMatch(fileName, regex, RegexOptions.IgnoreCase);
    }

    private static bool WildcardMatchesUnixStyle(string pattern, string text)
    {
        var regex = "^" + Regex.Escape(pattern)
                               .Replace("//*", ".*")
                               .Replace("//?", ".")
                    + "$";

        return Regex.IsMatch(text, regex);
    }

Hay algo curioso, incluso la API de Windows PathMatchSpec no está de acuerdo con FindFirstFile . Solo prueba a1*. , FindFirstFile dice que coincide con a1 , PathMatchSpec dice que no.

Answer 10

d* significa que debe coincidir con cero o más caracteres " d ". Entonces cualquier cadena es una coincidencia válida. Prueba d+ lugar!

Para tener soporte para patrones de comodines, reemplazaría los comodines con los equivalentes de RegEx. Al igual que * convierte en .* Y ? se convierte en .? . Entonces tu expresión anterior se convierte en d.*