Regex exclude text between parenthesis from match

given the following text:

{field1} == value1 && {field2} == value2  && ({field3} == value3 && {field4} == value4) && {field5} == value5

I'm trying to create a regex that match all the && on that text but excluding the ones between parentheses (so the && between value3 and field4 should be ignored). I've been able to do it with the following regex: (\&{2})(?![^\(]*\)) [this one works and it's doing what I need] but the problem is that I'm using Golang and doesn't support negative lookahead. There is any way to do it without negative lookahead? Parentheses can not be nested.

Basically I want to split by the && but ignoring the ones between parentheses and get something like:

[&&, &&, &&]
[{field1} == value1, {field2} == value2, ({field3} == value3 && {field4} == value4), {field5} == value5]

Thanks!

You might use a technique by which everything that isn't wanted is matched, but not captured, and everything that is wanted is matched and captured (i.e., saved to a capture group). You can do that with the following regular expression.

\([^\]]*\)|(&&)

which reads, "match a string enclosed in parentheses or (|) match the string "&&" and save it to capture group 1". The idea is to (in code) disregard matches that are not captured.

For the following string the matches (denoted by "m"s) and captures (denoted by "c"s) are shown.

{f1} == v1 && {f2} == v2  && ({f3} == v3 && {f4} == v4) && {f5} == v5
           mm                mmmmmmmmmmmmmmmmmmmmmmmmmm mm
           cc                                           cc

Demo

At the beginning of the string ({) neither \([^\]]*\) nor (&&) are matched, so the string pointer is advanced by one character to f. Again, there is no match so the string pointer is advance one more character, to 1. This continues (with no matches) until the first & is reached. \([^\]]*\) is not matched but (&&) is. We are interested in that match because it is captured (to capture group 1).

The string pointer is then moved one character ahead at a time, with no more matches found, until ( is reached. At that point, ({f3} == v3 && {f4} == v4) is matched by \([^\]]*\), but since it is not captured we pay no attention to it. This continues until the end of the string is reached.

Alternatively, we could use the regular expression

\([^\]]*\)|&&

and examine the first character of each match. If it is ( we discard the match from consideration.

When each match of && is found we might (in code) replace it with another (possibly empty) string, obtain its offset into the string (for some purpose) or simply increment a counter of the number of matches in the string. This of course depends on why we want to match those strings.

I am not familiar with Golang, but short of using a proper language parser you could do this with 3 regex:

1. replace all && inside parenthesis with a placeholder char
2. split on &&
3. restore the && in each array item from the placeholder char