有人可以解释这种 RegEx 行为吗？

Question

I experience a strange behaviour when working with RegEx.

dataString = "#Name #Location New York #Rating"
string[] rawValues = Regex.Split(dataString.Trim(), "(^|\\s)+#\\w+");

The pattern matches: "#Name", " #Location", " #Rating" (which is what I intend to match).
The split returns: ["", "", "", " ", "New York", " ", ""]

Question #1: The cunfusion starts already here. Why are there empty strings at positions 0,1,2 ? Two for the matches and one because it was at the first position of the string?

But this was not the strange part.

string[] rawValues = Regex.Split(dataString.Trim(), "(\\s|^)+#(\\w*[A-Za-z_]+\\w*)");

The pattern matches: "#Name", " #Location", " #Rating" (the same as before).
But the split returns: ["", "", "Name", "", " ", "Location"," New York", " ", "Rating",""]

Question #2: A pattern which leads to the exact same match, results in a totally different split output. How is this possible??

Answer 1

The reason is this sentence from MSDN :

If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array.

You you shouldn't use capturing groups in Split if you really just want to split the string at matches. You can avoid capturing groups, by using (?:...) in place of every (...) you have.

Plus, as you correctly assumed. The first and last "" originate from the fact that the string starts and ends with a match (so the empty string before and after these matches will be reported in the split).

Here is a regular expression that is better suited for you purposes:

@"(?:^|\s+)#\w*[A-Za-z_]+\w*"

Note that having the + outside of your first subpattern was also unnecessary and led to awkward side effects. Firstly it allowed the group to capture multiple times (which is why you got two addition "" , "" : one for ^ and one for \\s ). Secondly, there is no need to repeat ^ after the first space character has been matched, so it is enough to repeat only the space character. Also, there is no need to group the word after # at all.

However, if all you want is to match something like #name when it is at the start of the string or preceded by a space (ie not* preceded by a **non-space character), why include possible spaces in the match at all. A negative lookbehind gives you a nice way out:

@"(?<!\S)#\w*[A-Za-z_]+\w*"

This does exactly what described above. The (?<!\\S) matches if there is no non-space character left to it (without including a space-character in the match if there is one). That covers both cases without alternation, and you don't need to Trim your key names.

Answer 2

Because the regular expression on which you are splitting matches 1 or more whitespace followed by a hash ('#') followed by 1 or more word characters.

Anything that matches that doesn't get included in the results.

There's two ways you can do this:

1. Split on what is not wanted and filter the results.
2. Actively search for only what is wanted.

Here's some code with both of the above options:

static void Main( string[] args )
{
    string   sourceText = "#Name #Location New York #Rating" ;

    // option 1: split on whitespace and then toss whatever isn't wanted
    string[] hashTokens1 = sourceText.Split().Where( x => x.StartsWith("#") ).ToArray() ;

    // option 2: actively search for what is desired
    string[] hashTokens2 = ParseSourceData( sourceText ).ToArray() ;

    return ;

}

private static readonly Regex hashTokenPattern = new Regex( @"#\w+");
private static IEnumerable<string> ParseSourceData( string s )
{
    for ( Match m = hashTokenPattern.Match( s ) ; m.Success ; m = m.NextMatch() )
    {
        yield return m.Value ;
    }
}

Myself, I'd use the 2nd option as it better states the case for what you're trying to accomplish. A good general rule is to prefer positive assertions or tests over negative.

You can also write the 2nd option as a "one-liner, thus:

// option 2: actively search for what is desired
Regex hashTokenPattern = new Regex( @"#\w+");
string[] hashTokens2 = hashTokenPattern.Matches(sourceText).Cast<Match>().Select(x=>x.Value).ToArray();