Regex to match nothing but zeroes after the first zero

Question

Using regular expressions, how can I make sure there are nothing but zeroes after the first zero?

ABC1000000 - valid 3212130000 - valid 0000000000 - valid ABC1000100 - invalid 0001000000 - invalid 

The regex without validation would be something like this - [A-Z0-9]{10}, making sure it is 10 characters.

Answer 1

You could update the pattern to:

^(?=[A-Z0-9]{10}$)[A-Z1-9]*0+$ 

The pattern matches:

• ^ Start of string
• (?=[A-Z0-9]{10}$) Positive looakhead, assert 10 allowed chars
• [A-Z1-9]* Optionally match any char of [A-Z1-9]
• 0+ Match 1+ zeroes
• $ End of string

Regex demo

If a value without zeroes is also allowed, the last quantifier can be * matching 0 or more times (and a bit shorter version by the comment of @Deduplicator using a negated character class):

^(?=[A-Z0-9]{10}$)[^0]*0*$ 

An example with JavaScript:

const regex = /^(?=[A-Z0-9]{10}$)[^0]*0*$/; ["ABC1000000", "3212130000", "0000000000", "ABC1000100", "0001000000"] .forEach(s =>   console.log(`${s} --> ${regex.test(s)}`) );

---

As an alternative without lookarounds, you could also match what you don't want, and capture in group 1 what you want to keep.

To make sure there are nothing but zeroes after the first zero, you could stop the match as soon as you match 0 followed by 1 char of the same range without the 0.

In the alternation, the second part can then capture 10 chars of range A-Z0-9.

^(?:[A-Z1-9]*0+[A-Z1-9]|([A-Z0-9]{10})$) 

The pattern matches:

• ^ Start of string
• (?: Non capture group for the alternation |
  • [A-Z1-9]*0+[A-Z1-9] Match what should not occur, in this case a zero followed by a char from the range without a zero
  • | Or
  • ([A-Z0-9]{10}) Capture group 1, match 10 chars in range [A-Z0-9]
• $ End of string
• ) Close non capture group

Regex demo

Answer 2

0[^0]

• a 0 followed by NOT a 0

I've written it in JS because it was easier to test, but it works in other languages as well. Note: it does not check length, but this regex is so much easier, combine this with a length check and your done.

If the regex matches, the string is invalid :) In the console I've negated it already to tell you if it is valid:

const strings = [   'BC1000000',   '3212130000',   '0000000000',   'ABC1000100',   '0001000000',   '1000000000',   '10000000000',   '1000000001' ];  strings.forEach(element => {     console.log(         element,         // true means length 10 and only trailing zeros          !/0[^0]/.test(element) && element.length == 10       ) });