Count Parentheses With Regular Expression

My string is: (as(dh(kshd)kj)ad)... ()() How is it possible to count the parentheses with a regular expression? I would like to select the string which begins at the first opening

Solution 1:

As I said in the comments, contrary to popular belief (don't believe everything people say) matching nested brackets is possible with regex.

The downside of using it is that you can only do it up to a fixed level of nesting. And for every additional level you wish to support, your regex will be bigger and bigger.

But don't take my word for it. Let me show you. The regex \([^()]*\)matches one level. For up to two levels see the regex here. To match your case, you'd need:

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

It would match the bold part: (as(dh(kshd)kj)ad)... ()()

Check the DEMO HERE and see what I mean by fixed level of nesting.

And so on. To keep adding levels, all you have to do is change the last [^()]* part to ([^()]*|\([^()]*\))* (check three levels here). As I said, it will get bigger and bigger.

Solution 2:

See Tim's answer for why this won't work, but here's a function that'll do what you're after instead.

function getFirstBracket(str){
  var pos = str.indexOf("("),
      bracket = 0;

  if(pos===-1) returnfalse;

  for(var x=pos; x<str.length; x++){
    var char = str.substr(x, 1);    
    bracket = bracket + (char=="(" ? 1 : (char==")" ? -1 : 0));
    if(bracket==0) returnstr.substr(pos, (x+1)-pos);
  }
  returnfalse;
}

getFirstBracket("(as(dh(kshd)kj)ad)... ()(");

Solution 3:

There is a possibility and your approach was quite good: Match will give you an array if you had some hits, if so you can look up the array length.

var str = "(as(dh(kshd)kj)ad)... ()()",
    match = str.match(new RegExp('.*?(?:\\(|\\)).*?', 'g')),
    count = match ? match.length : 0;

This regular expression will get all parts of your text that include round brackets. See http://gskinner.com/RegExr/ for a nice online regex tester.

Now you can use count for all brackets. match will deliver a array that looks like:

["(", "as(", "dh(", "kshd)", "kj)", "ad)", "... (", ")", "(", ")"]

Now you can start sorting your results:

var newStr = '', open = 0, close = 0;

for (var n = 0, m = match.length; n < m; n++) {
    if (match[n].indexOf('(') !== -1) {
        open++;
        newStr += match[n];
    } else {
        if (open > close) newStr += match[n];
        close++;
    }
    if (open === close) break;
}

... and newStr will be (as(dh(kshd)kj)ad)

This is probably not the nicest code but it will make it easier to understand what you're doing.

With this approach there is no limit of nesting levels.

Solution 4:

This is not possible with a JavaScript regex. Generally, regular expressions can't handle arbitrary nesting because that can no longer be described by a regular language.

Several modern regex flavors do have extensions that allow for recursive matching (like PHP, Perl or .NET), but JavaScript is not among them.

Solution 5:

No. Regular expressions express regular languages. Finite automatons (FA) are the machines which recognise regular language. A FA is, as its name implies, finite in memory. With a finite memory, the FA can not remember an arbitrary number of parentheses - a feature which is needed in order to do what you want.

I suggest you use an algorithms involving an enumerator in order to solve your problem.