Regular expression wildcard

Question

I've just started using Regular Expressions and this is so overwhelming that even after reading documentation I can't seem to find where to start to help with my problem.

I have to a bunch of strings.

 "Project1 - Notepad"
 "Project2 - Notepad"
 "Project3 - Notepad"
 "Untitled - Notepad"
 "HeyHo - Notepad"

And I have a string containing a wild card.

"* - Notepad"

I would need that if I compare any of these strings with the one containing the wildcard it returns true. (With Regex.IsMatch() or something like that..)

I don't usually asks for answers like that but I just can't find what I need. Could someone just point me out in the right direction ?

Answer 1

The wildcard * is equivalent to the Regex pattern ".*" (greedy) or ".*?" (not-greedy), so you'll want to perform a string.Replace():

string pattern = Regex.Escape(inputPattern).Replace("\\*", ".*?");

Note the Regex.Escape(inputPattern) at the beginning. Since inputPattern may contain special characters used by Regex, you need to properly escape those characters. If you don't, your pattern would explode.

Regex.IsMatch(input, ".NET"); // may match ".NET", "aNET", "FNET", "7NET" and many more

As a result, the wildcard * is escaped to \\*, which is why we replace the escaped wildcard rather than just the wildcard itself.

---

To use the pattern

you can do either:

Regex.IsMatch(input, pattern);

or

var regex = new Regex(pattern);
regex.IsMatch(input);

---

Difference between greedy and not-greedy

The difference is in how much the pattern will try to match.

Consider the following string: "hello (x+1)(x-1) world". You want to match the opening bracket ( and the closing bracket ) as well as anything in-between.

Greedy would match only "(x+1)(x-1)" and nothing else. It basically matches the longest substring it can find.

Not-greedy would match "(x+1)" and "(x-1)" and nothing else. In other words: the shortest substrings possible.

---

How to escape the wildcard character?

@MaximZabolotskikh asked about the possibility of escaping the wildcard character, so that "Hello \* World" would literally match "Hello * World".

To do this would require multiple substitutions.

1. Escape the regex.

2. Substitute any occurrence of \\\\ (double backslash) with the escape character \x1b. This allows us to identify backslashes that were in the original input.

3. Substitute any occurrence of \x1b\x1b with \\\\. This allows matching a literal \ by using \\.

4. Use the negative lookbehind pattern (?<!\x1b)\\\* to substitute * with the wildcard pattern (either .* or .*?) but only if it isn't preceded by a backslash. This will insert the wildcard pattern in "Hello * World" and "Hello \\* World", but not in Hello \* World. We need to match \\\* because * is changed to \* after escaping, so we're actually matching a literal \ (using \\) and a literal * (using \*).

5. Any escaped * will now be \x1b\\*, which will eventually be substituted to \\\\*, but we actually want it to be \\* instead so we can match a literal * later on. Therefore, substitute \x1b\\* with \\*.

6. Finally, substitute all \x1b back to \\.

Here's an example (I am using @"" here to avoid typing double backslashes):

string pattern = Regex.Escape(inputPattern);
pattern = pattern.Replace(@"\\", "\x1b");
pattern = pattern.Replace("\x1b\x1b", @"\\");
pattern = Regex.Replace(pattern, @"(?<!\x1b)\\\*", ".*?");
pattern = pattern.Replace("\x1b\\*", @"\*");
pattern = pattern.Replace('\x1b', '\\');

Answer 2

I just wrote this quickly (based off of Validate that a string contain some exact words)

    static void Main()
    {
        string[] inputs = 
        {
            "Project1 - Notepad", // True
            "Project2 - Notepad", // True
            "HeyHo - Notepad", // True
            "Nope - Won't work" // False
        };

        const string filterParam = "Notepad";
        var pattern = string.Format(@"^(?=.*\b - {0}\b).+$", filterParam);

        foreach (var input in inputs)
        {
            Console.WriteLine(Regex.IsMatch(input, pattern));
        }
        Console.ReadLine();
    }

Answer 3

You should do like this:

string myPattern = "* - Notepad";
foreach(string currentString in myListOfString)
    if(Regex.IsMatch(currentString, myPattern, RegexOptions.Singleline){
        Console.WriteLine("Found : "+currentString);
    }
}

By the way I saw you came from Montreal, additional french documentation + usefull tool: http://www.olivettom.com/?p=84

Good luck!

Answer 4

Seems like the pattern you want is the following:

/^.+-\s*Notepad$/

This pattern will match an entire string if it ends with "- Notepad".