JS: Trying to test for a very specific pattern

Question

I need to validate a string for given specifications:

const string = 'd(iig(i)), d(iitm), d' // is valid

Mainly the string represents one or multiple blocks of d, which can be without brackets or empty brackets. Each block is separated by comma and an optional space.

Inside of this block there can be g, i, t or m. Only g can optionaly open new bracket.

I started with this regex:

if (!/^[dgitm, ()]*$/.test(string)) {
  throw Error('Pattern has invalid character')
}

But I don't know how to treat these specifications:

Each block has to be separated by a comma (optinal with space)
Space is only allowed (optional) between d-blocks
d and g could have following brackets; i, t and m should not have following brackets
d is never inside any bracket

Valid

dd(ii)
d(i),d(g)
d(g(iig))
d(g(iig(i)))

Invalid

d(g(d))    // no nested d
d(x)       // invalid character
d(i())     // no brackets for i (only d or g)
d(ii)d(ii) // missing comma
i          // missing first level d

Update

Removed the spec for balanced brackets, as this can't be tested by regEx.

It will be helpful if you add more valid & invalid samples in question. — anubhava, Jan 19 '18 at 18:36
You might want to try jison.js for this instead of regular expressions. — samsonthehero, Jan 19 '18 at 18:37
You [can't](https://stackoverflow.com/a/546457/3103891) use regex to validate brackets — GalAbra, Jan 19 '18 at 18:40
can a `g` appear within a `g(...)` bracket? If so, regex can't solve this. — le_m, Jan 19 '18 at 18:43
Other than the brackets check, this regex satisfies all of your conditions: `/^(d$?([itm]+|g\(?|$)*(, )?)+$/g` — GalAbra, Jan 19 '18 at 18:57
@GalAbra Thanks for that. Rule 4 is missing: `d(g(d))` should be invalid. — user3142695, Jan 19 '18 at 19:37

GalAbra · Accepted Answer · 2018-01-20T10:53:09.423

^d+(\((g\(|[git](?!\()|\))+)*(,d+(\((g\(|[git](?!\()|\))+)*)*$

It can be tested here.

Explanation:

^d+                                 The input must start with some 'd's (m>=1 times)

// First parenthesis' content:
(\((g\(|[git](?!\()|\))+)*          The following can appear n>=0 times:
                                    '(', then the following can appear p>=1 times:
                                        'g', then one of the following:
                                            - 'g('
                                            - ')'
                                            - 'g'/'i'/'t' - without a '(' after them
                                              (using negative lookahead)

// Every other element (optional):
(,d+(\((g\(|[git](?!\()|\))+)*)*    Starts with a ',d', ',dd' or ',ddd', etc.
                                    then the same as the first parenthesis' content

As I mentioned in the comments, you can't validate brackets with regex. However you can either implement an existing algorithm for that, or get a sense of initial validation by comparing the amount of opening and closing parenthesis (which obviously should be equal).

EDIT: Thank you, @anubhava, for the correction

It makes `d(i())` a valid input but as per OP it is not – anubhava Jan 20 '18 at 10:37 — anubhava, Jan 20 '18 at 10:37
@anubhava Thanks! I fixed it with a negative lookahead – GalAbra Jan 20 '18 at 10:46 — GalAbra, Jan 20 '18 at 10:46

JS: Trying to test for a very specific pattern

1 Answers1