Is there a better way to write a regex that does not match on leading and trailing spaces along with a character limit?

Question

The regex I have is...

^[A-z0-9]*[A-z0-9\s]{0,20}[A-z0-9]*$

The ultimate goal of this regex is not to allow leading and trailing spaces, while limiting the characters that are entered to 20, which the above regex doesn't do a good job at.

I found a some questions similar to this and the closest one to this would be How to validate a user name with regex?, but it did not limit the number of chars. This did solve the problem of leading and trailing spaces.

I also saw a way using negation and another negative lookahead, but that didn't work out so well for me.

Is there a better way to write the regex above with the 20 character limit? The repeat of the allowed characters is pretty ugly especially when the list of the allowed characters are large and specific.

Answer 1

Hmm, if you need to exclude the single character text, I would go with:

^[A-z0-9][A-z0-9\s]{0,18}[A-z0-9]$

If a single character is also acceptable:

^[A-z0-9](?:[A-z0-9\s]{0,18}[A-z0-9])?$

Answer 2

Update:

I like this one even better. We use a negative lookahead to make sure there isn't ^\s (whitespace at the beginning of the string) or \s$ whitespace at the end of the string. And then match 1 alphanumeric character. We repeat this 1-20 times.

/^(?:(?!^\s|\s$)[a-z0-9\s]){1,20}$/i

Demo

^            (?# beginning of string)
(?:          (?# non-capture group for repetition)
  (?!        (?# begin negative lookahead)
    ^\s      (?# whitespace at beginning of string)
   |         (?# OR)
    \s$      (?# whitespace at end of string)
  )          (?# end negative lookahead)
  [a-z0-9\s] (?# match one alphanumeric/whitespace character)
){1,20}      (?# repeat this process 1-20 times)
$            (?# end of string)

---

Initial:

I use a negative lookahead at the beginning of the string ((?!...)) to make sure that we don't start off with whitespace. Then we check for 0-19 alphanumeric (case-insensitive thanks to i modifier) or whitespace characters. Finally, we make sure we end with a pure alphanumeric character (no whitespace) since we can't use lookbehinds in Javascript.

/^(?!\s)[a-z0-9\s]{0,19}[a-z0-9]$/i

Answer 3

• I think your regex limits the input to 22 characters, not 20.
• Are you aware that character range [A-z] includes characters [\]^_`?

• I think I'd do something like this:

  input = input.trim().replace(/\s+/, ' ');
  if (input.length > MAX_INPUT_LENGTH ||
      ! /^[a-z ]+$/i.match(input) ) {
    # raise exception?
  }
  

Answer 4

\S matches a non-whitespace character. Therefore this should match what you're looking for:

^\S.{0,18}\S$

That is, a non-space character \S, followed by up to 18 of any type of character . (space or not), and finally a non-space character.

The only limitation of the above regex is that the value must be at least 2 characters. If you need to allow 1 character, you can use:

^\S(.{0,18}\S)?$

If you're looking to validate a user name (as you implied but didn't explicitly state) you're probably looking to allow only numbers, letters, and underscores. In that case, ^\w{1,20}$ will suffice.

Answer 5

use this pattern ^(?!\s).{0,20}(?<!\s)$

• ^(?!\s) start of line does not see a space
• .{0,20} followed by 0 to 20 characters
• (?<!\s)$ ends with a character that is not a space

Demo

or this pattern ^(\S.{0,18}\S)?$
Demo