Regex - Removing empty strings

Question

I have written the folllowing regex and would like to get empty strings removed automatically and could not find any equivalent to RemoveEmptyEntries for Regex which I found only for the Split method in string.

    string test = "{ key1 = { key2= xx } | key3 = y | key4 = z }";
    string[] help = Regex.Split(test, "(=)|({)|(})|(\\|)");

The result string array contains elements which are empty. I would like to run the regular expression without yielding any empty strings contained in the result.

I will run this code very, very frequently - thus I need it as efficient as possible. Updates: As this is a parser I need to keep the tokens and I found only a way with Regex to keep them.

Answer 1

I didn't quite figure out your question. But "^$" would mean a line that ends next to where it starts, therefore an empty line. Does that help?

Answer 2

As for efficiency: If the stars are lucky, you can gain some performance by compiling the regex:

Regex r = new Regex ("<regex goes here>", RegexOptions.Compiled);

Answer 3

To remove spaces from a string just do this

Regex exp = new Regex(@"\s+");
string test = "{ key1 = { key2= xx } | key3 = y | key4 = z }";
string result = test.Replace(exp, string.Empty);

Or you could also do the following (did not test which one works faster)

Regex.Replace(test, " ", string.Empty, RegexOptions.Compiled)

Here is what Jeff Atwood (incidentally one of the creators of StackOverFlow has to say about compiled regex )

After this you can user your split code to put the keys into the string array.

Answer 4

Maybe not a full solution to the question, but I have a few remarks for the problem at hand (tokenizing a string):

the original regex:    (=)|({)|(})|(\|)
is equivalent to:      (=|{|}|\|)
is equivalent to:      ([={}|])

All of the above expressions return the same 21 elements, but they perform differently. I set up a quick test going over 100,000 iterations of Split() operations using pre-built Regex objects with RegexOptions.Compiled and the Stopwatch class.

• regex #1 takes 2002ms on my hardware
• regex #2 takes 1691ms
• regex #3 takes 1542ms
• regex #4 takes 1839ms (that's the one below)

YMMV.

However, the desired elements can still be surrounded by white space. I figure this is undesired as well, so the regex I would split on would be this:

\s*([={}|])\s*

The returned elements are:

["", "{", "key1", "=", "", "{", "key2", "=", "xx", "}", "", "|", "key3", "=", "y", "|", "key4", "=", "z", "}", ""]

The few remaining empty strings should not pose a big problem performance-wise when iterating the array and can be taken care of (read: ignored) when they are encountered.

EDIT: If you measure performance it is possible that you find splitting on ([={}|]) and trimming the array elements "manually" is faster than splitting on \s*([={}|])\s*. Just try what works better for you.

Answer 5

Rather than splitting the string using the regex you could modify your regular expression and return a match collection. Something like this:

string test = "{ key1 = { key2= xx } | key3 = y | key4 = z }";

Regex regex = new Regex("[={}|]|[^\\s={}|]{1,}");
MatchCollection matches = regex.Matches(test);

string[] help = new string[matches.Count];

for (int index = 0; index < matches.Count; index++)
{
    help[index] = matches[index].Value;                
}

This will return the same as your regular expression minus the empty (white space) elements in the final array.

Answer 6

So you want multiple occurrences of delimiters between values to be matched only once.

\s*[{}=|][\s{}=|]*

This should match, in this order, any amount of whitespace, one delimiter, and any amount of both whitespace and further delimiters.

Adding C# string escapes and a compilation declaration:

Regex regex = new Regex("\\s*[{}=|][\\s{}=|]*");