Regex Nested Parentheses

RegEx for capturing values in nested brackets

If everything in between the [] would be desired, then we might simplify our expression to maybe:

(?:\[+)(.+?)(?:\]+)

Here, we capture our likely desired substring in this capturing group:

(.+?)

Then, we add two boundaries on its left and right sides using two non-capturing groups:

(?:\[+)
(?:\]+)

Demo

const regex = /(?:\[+)(.+?)(?:\]+)/g;const str = `[[[hello-hello]][[hi-hi]]][[hi hi]]]`;const subst = `$1`;
// The substituted value will be contained in the result variableconst result = str.replace(regex, subst);
console.log('Substitution result: ', result);

How can I match nested brackets using regex?

Many regex implementations will not allow you to match an arbitrary amount of nesting. However, Perl, PHP and .NET support recursive patterns.

A demo in Perl:

#!/usr/bin/perl -w

my $text = '(outer
   (center
     (inner)
     (inner)
   center)
 ouer)
 (outer
   (inner)
 ouer)
 (outer
 ouer)';

while($text =~ /(\(([^()]|(?R))*\))/g) {
  print("----------\n$1\n");
}

which will print:

----------
(outer
   (center
     (inner)
     (inner)
   center)
 ouer)
----------
(outer
   (inner)
 ouer)
----------
(outer
 ouer)

Or, the PHP equivalent:

$text = '(outer
   (center
     (inner)
     (inner)
   center)
 ouer)
 (outer
   (inner)
 ouer)
 (outer
 ouer)';

preg_match_all('/(\(([^()]|(?R))*\))/', $text, $matches);

print_r($matches);

which produces:

Array
(
    [0] => Array
        (
            [0] => (outer
   (center
     (inner)
     (inner)
   center)
 ouer)
            [1] => (outer
   (inner)
 ouer)
            [2] => (outer
 ouer)
        )

...

An explanation:

(          # start group 1
  \(       #   match a literal '('
  (        #   group 2
    [^()]  #     any char other than '(' and ')'
    |      #     OR
    (?R)   #     recursively match the entir pattern
  )*       #   end group 2 and repeat zero or more times
  \)       #   match a literal ')'
)          # end group 1

EDIT

Note @Goozak's comment:

A better pattern might be \(((?>[^()]+)|(?R))*\) (from PHP:Recursive patterns). For my data, Bart's pattern was crashing PHP when it encountered a (long string) without nesting. This pattern went through all my data without problem.

Regex nested parentheses

You can use this:

(?>\w+\.)?\w+\((?>\((?<DEPTH>)|\)(?<-DEPTH>)|[^()]+)*\)(?(DEPTH)(?!))|\w+

With your example you obtain:

0 => username
1 => TB_PEOPLE.fields(FirstName,LastName,TB_PHONE.fields(num_phone1, num_phone2))
2 => password

Explanation:

(?>\w+\.)? \w+ \(    # the opening parenthesis (with the function name)
(?>                  # open an atomic group
    \(  (?<DEPTH>)   # when an opening parenthesis is encountered,
                     #  then increment the stack named DEPTH
  |                  # OR
    \) (?<-DEPTH>)   # when a closing parenthesis is encountered,
                     #  then decrement the stack named DEPTH
  |                  # OR
    [^()]+           # content that is not parenthesis
)*                   # close the atomic group, repeat zero or more times
\)                   # the closing parenthesis
(?(DEPTH)(?!))       # conditional: if the stack named DEPTH is not empty
                     #  then fail (ie: parenthesis are not balanced)

You can try it with this code:

string input = "username,TB_PEOPLE.fields(FirstName,LastName,TB_PHONE.fields(num_phone1, num_phone2)),password";
string pattern = @"(?>\w+\.)?\w+\((?>\((?<DEPTH>)|\)(?<-DEPTH>)|[^()]+)*\)(?(DEPTH)(?!))|\w+";
MatchCollection matches = Regex.Matches(input, pattern);
foreach (Match match in matches)
{
    Console.WriteLine(match.Groups[0].Value);
}

Regular expression for nested brackets that contain a symbol

I would tokenise the input, splitting it by commas and parentheses, keeping also these delimiters as results. Then use a recursive algorithm to detect whether commas appear for a certain pair of parentheses and make the appropriate replacement.

Here is a function doing the job:

function replaceWithBrackets($s) {

    function recur(&$tokens) {
        $comma = false;
        $replaced = "";
        while (true) {
            $token = current($tokens);
            next($tokens);
            if ($token == ")" || $token === false) break; 
            if ($token == "(") {
                [$substr, $subcomma] = recur($tokens);
                $replaced .= $subcomma ? "[$substr]" : "($substr)";
            } else {
                $comma = $comma || $token == ",";
                $replaced .= $token;
            }
        }
        return [$replaced, $comma];
    }
    
    $tokens = preg_split("~([(),])~", $s, 0, PREG_SPLIT_DELIM_CAPTURE);
    return recur($tokens)[0];
}

Regular expression to return string split up respecting nested parentheses

Using regex only for the task might work but it wouldn't be straightforward.

Another possibility is writing a simple algorithm to track the parentheses in the string:

1. Split the string at all parentheses, while returning the delimiter (e.g. using re.split)
2. Keep a counters tracking the parentheses: start_parens_count for ( and end_parens_count for ).
3. Using the counters, proceed by either splitting at white spaces or adding the current data into a temp var ( term)
4. When the left most parenthesis has been closed, append term to the list of values & reset the counters/temp vars.

Here's an example:

import re

string = "1 2 3 (test 0, test 0) (test (0 test) 0)"

result, start_parens_count, end_parens_count, term = [], 0, 0, ""
for x in re.split(r"([()])", string):
    if not x.strip():
        continue
    elif x == "(":
        if start_parens_count > 0:
            term += "("
        start_parens_count += 1
    elif x == ")":
        end_parens_count += 1
        if end_parens_count == start_parens_count:
            result.append(term)
            end_parens_count, start_parens_count, term = 0, 0, ""
        else:
            term += ")"
    elif start_parens_count > end_parens_count:
        term += x
    else:
        result.extend(x.strip(" ").split(" "))

print(result)
# ['1', '2', '3', 'test 0, test 0', 'test (0 test) 0']

Not very elegant, but works.

Related Topics