Limiting the regex string length for a specific pattern

Question

Can anyone please suggest a regex for the below mentioned conditions.

Should not allow only blank spaces(white spaces).
Blank spaces are allowed only if atleast one non whitespace character is present.
Any characters is allowed.
Length should be limited to 50 characters.

I tried this pattern .*[^ ].* from Regex pattern for "contains not only spaces". Can you please suggest how to limit this to 50 characters.

`*` means *zero or more*. For *zero up to a maximum of 50* use `{,50}` in place of `*`. — BoarGules, May 18 '18 at 09:47
\S{1,50} it will check for at least 1 and max 50 non white space character — Abhishek Singh, May 18 '18 at 09:55
@AbhishekSingh This will not work! Please go through the question carefully. This is not what I am looking for. — Ashwin Shirva, May 18 '18 at 09:59
@AshwinShirva I think you can't do that with a single regex. You want it to count the number of nonblanks (minimum 1) and the number of characters (maximum 50). The rule of thumb is "a regex can count only one thing at a time". — BoarGules, May 18 '18 at 10:27
Why would you use regex at all? Just check that the strings length is less or equal to 50 and that the trimmed string is not empty. — Sebastian Proske, May 18 '18 at 10:46
See [my answer below](https://stackoverflow.com/a/50409973/3832970). Note you can't use lookarounds with Go regexp, but if you insist, you may use the same one as Java's with a [go-pcre library](https://github.com/d4l3k/go-pcre) or any other Go PCRE library (see [this one, eg.](https://github.com/glenn-brown/golang-pkg-pcre)). — Wiktor Stribiżew, May 22 '18 at 21:34

score 1 · Answer 1 · answered May 18 '18 at 10:29

1

I suppose lookahead in regex can help out.

Try adding (?=.{0,50}$) in front of your regex. To have something like this:

(?=.{0,50}$)^.*[^ ].*

You may change the the {0,50} to {1,50} if you don't want to allow empty strings.

answered May 18 '18 at 10:29

owsega

This works perfectly with java. Do you have an equivalent Go lang solution? Because lookaheads don't work with golang – Ashwin Shirva May 18 '18 at 10:32
Unfortunately I don't know Go. Without lookahead you may need to write additional code – owsega May 18 '18 at 10:40
Is there a way to do this without a lookahead? – Ashwin Shirva May 18 '18 at 10:43
Yes, but it involves 50 alternations. `(\S.{,49}|.\S.{,48}|.{2}\S.{,47}|...)` – Sebastian Proske May 18 '18 at 10:48
Yes, it is possible, but you won't like it: you will have to spell out each possible variation. So, for a string with 3 char limit, it would look like `^( {2}\S| \S |\S )$`. Imagine what the expression for 50 chars will look like. Certainly you may create it dynamically, but why not just use `(len(s) <= 50 || len(s) >= 0) && len(strings.TrimSpace(s)) != 0`? – Wiktor Stribiżew May 18 '18 at 10:53

Wiktor Stribiżew · Answer 2 · 2018-05-18T11:45:05.977

You can't use lookarounds in Go regex patterns. In Java, to match a non-blank string with 0 to 50 chars, you may use

s.matches("(?s)(?!.{51})\\s*\\S.*")

The pattern matches the whole string (matches anchors the match by default) and means:

(?s) - Pattern.DOTALL inline modifier making . match newlines, too
(?!.{51}) - a negative lookahead disallowing 51 chars in the string (so, less than 51 is allowed, 0 to 50, it is equal to (?=.{0,50)$)
\\s* - 0+ whitespaces
\\S - a non-whitespace char
.* - any 0+ chars to the end of the string.

In Go, just use a bit of code. Import strings and use

len(s) <= 50 && len(s) >= 1 && len(strings.TrimSpace(s)) != 0

Here, len(s) <= 50 && len(s) >= 1 limit the string length from 1 to 50 chars and len(strings.TrimSpace(s)) != 0 forbids an empty/blank string.

2 Answers2