Regex to find if there is only one block of code

Question

My input is a string, I want to validate that there is only one first-level block of code.

Examples :

{ abc }              TRUE
{ a { bc } }         TRUE
{ a {{}} }           TRUE
{ abc {efg}{hij}}    TRUE
{ a b cde }{aa}      FALSE

/^\{.*\}$/ is valid for the 5 cases, can you help me to find a regex invalid for the last case ?

Language is JavaScript.

Use a lookahead instead of looking at the end of the string `(?={)`. If the lookahead evaluates to true, then your regex doesn't match. — RevanProdigalKnight, Jul 25 '14 at 12:11
Traditionally regular expressions can't handle nested constructs. Modern regular expressions parsers are better, but handling nested constructs is still not perfect. — Some programmer dude, Jul 25 '14 at 12:13
Can you use anything else? Something like a small state machine would be easier to do and probably clearer — Hugo Dozois, Jul 25 '14 at 13:25

score 4 · Answer 1 · edited May 23 '17 at 12:20

EDIT: I started writing the answer before JavaScript was specified. Will leave it as for the record as it fully explains the regex.

In short: In JavaScript I cannot think of a reliable solution. In other engines there are several options:

Recursion (on which I will expand below)
Balancing group (.NET)

For solutions 2 (which anyhow won't work in JS either), I'll refer you to the example in this question

Recursive Regex

In Perl, PCRE (e.g. Notepad++, PHP, R) and the Matthew Barnett's regex module for Python, you can use:

^({(?:[^{}]++|(?1))*})$

The idea is to match exactly one set of nested braces. Anything more makes the regex fail.

See what matches and fails in the Regex Demo.

Explanation

The ^ anchor asserts that we are at the beginning of the string
The outer parentheses define Group 1 (or Subroutine 1)
{ match the opening brace
(?: ... )* zero or more times, we will...
[^{}]++ match any chars that are not { or }
OR |
(?1) repeat the expression of subroutine 1
} match closing brace
The $ anchor asserts that we are at the end of the string. Therefore,

Unfortunately, the OP has specified now that they're looking for javascript and this solution is invalid in javascript. +1 for the recursive regex demo, though. — RevanProdigalKnight, Jul 25 '14 at 12:19

score 1 · Answer 2 · edited Jun 20 '20 at 09:12

1

This is a terrible workaround.

Since this is in Javascript there's not really much to do, but please see the following regex:

/^{([^{}]*|{})*}$/

Where you copy ([^{}]*|{})* and insert it between the last pair of curly brackets (rinse and repeat). Every duplication of this pattern allows another level of nesting between your elements. (This is a workaround for the lack of recursion in JS regex, required to solve nesting problems.)

Online Regex Demo

edited Jun 20 '20 at 09:12

Community

1
1

answered Jul 25 '14 at 12:52

Unihedron

10,902
13
62
72

Very practical, +1 for copy-paste regex, that would probably work in realistic cases where nesting is limited. :) – zx81 Jul 26 '14 at 00:45

asontu · Answer 3 · 2014-09-02T08:34:56.313

In JavaScript what you need to do is strip out all the nested blocks until no nested blocks are left and then check whether there are still multiple blocks:

var r = input.replace(/(['"])(?:(?!\1|\\).|\\.)*\1|\/(?![*/])(?:[^\\/]|\\.)+\/[igm]*|\/\/[^\n]*(?:\n|$)|\/\*(?:[^*]|\*(?!\/))*\*\//gi, '');

if (r.split('{').length != r.split('}').length || r.indexOf('}') < r.indexOf('{')) {
    // ERROR
    continue;
}

while (r.match(/\{[^}]*\{[^{}]*\}/))
    r = r.replace(/(\{[^}]*)\{[^{}]*\}/g, '$1');
if (r.match(/\}.*\{/)
    // FALSE
else
    // TRUE

Working JSFiddle

Be sure to make the regex in the while and the regex in the replace match the same otherwise this might result in infinite loops.

Updated to address ERROR cases and remove anything in comments, strings and regex-literals first after Unihedron asked.

Would return TRUE, but it's an "improper" code block. If you wanna check for unmatched open curly braces that's a different problem, though related indeed. But then you'd want to consider stuff like `{ print "Went there {" } /* } { Dang edge cases! } */`. I wrote about scenarios like that here: http://stackoverflow.com/questions/25402109/regex-for-comments-in-strings-strings-in-comments-etc — asontu, Sep 02 '14 at 08:06

score -1 · Answer 4 · answered Sep 02 '14 at 10:55

-1

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

Code for brackets

answered Sep 02 '14 at 10:55

Jon Jin

1
2

No explanation, long repetitive regex dealing with regular rather than curly brackets. – asontu Sep 02 '14 at 11:49
It's for validation brackets ()()- valid ())- invalid ()()())-invalid – Jon Jin Sep 02 '14 at 11:53

Regex to find if there is only one block of code

4 Answers4

Recursive Regex

This is a terrible workaround.

Linked