RegEx for matching specific phone numbers

Question

I'm trying to see if a string matches my country's phone number format, which is the area code (two digits that may or may not be preceded by a 0 and might also be between parenthesis) followed by 8 or 9 digits in which there may be an dash character before the 4 last digits. These are some valid formats:

'00 00000000'
'000-000000000'
'000 00000-0000'
'00 0000-0000'
'(00) 0000-0000'
'(000) 000000000'

So far this is the working expression I have:

p = /0?\d{2}\s?-?\s?\d{4,5}\s?-?\s?\d{4}/

I tried to use a conditional to see if the area code is inside parenthesis with /?(\() 0?\d{2}\)|0?\d{2} \s?-?\s?\d{4,5}\s?-?\s?\d{4}/ but got the (repl):1: target of repeat operator is not specified: /?(\() 0?\d{2}\)|0?\d{2} \s?-?\s?\d{4,5}\s?-?\s?\d{4} error.

What am I doing wrong here?

Answer 1

Do not validate phone numbers with regular expressions. I bet you do not want to rule out those occasionally typing 2 consequent spaces or something.

Instead, filter out all the non-digits and leading zeroes, and then validate. Like this:

number.gsub(/\D+/, '').gsub(/\A0+/) =~ /\d{8,9}/

I am not sure it would suit your needs out of the box, but I bet you’ve got the point. After all, [000]1234 56789 is an understandable phone number.

Answer 2

My answer addresses your conditional idea for the optional parenthesis.
Ruby supports conditionals since v2.0. The syntax is (?(A)X|Y): If A is true, X else Y.

• Put an optional capturing group containing an opening parenthesis at start:
  ^(\()?
• Later anywhere in the pattern check if it succeeded:
  (?(1)\) |[ -])
  If success: require a closing ) followed by space | else: [ -] space or dash.

So the whole pattern with conditional could be

^(\()?0?\d{2}(?(1)\) |[ -])\d{4,5}[ -]?\d{4}$

See the demo at Rubular or Regex101. Adjust further to your needs.

An alternative to use alternation (?:\(abc\)|abc) which @CarySwoveland answered already but @AlekseiMatiushkin's answer surely will make life easier I think.

Answer 3

There might be several ways to validate these numbers. One way would be that, we write all our possible phone numbers, then write an expression for it. Maybe, similar to:

[0-9]{2,3}(\s|-)[0-9]{4,5}-?[0-9]{3,4}

Test

re = /[0-9]{2,3}(\s|-)[0-9]{4,5}-?[0-9]{3,4}/m
str = '\'00 00000000\'
\'000-000000000\'
\'000 00000-0000\'
\'00 0000-0000\''

# Print the match result
str.scan(re) do |match|
    puts match.to_s
end

Demo

This snippet is just to show the capturing groups and that the expression might be valid:

const regex = /[0-9]{2,3}(\s|-)[0-9]{4,5}-?[0-9]{3,4}/gm;
const str = `'00 00000000'
'000-000000000'
'000 00000-0000'
'00 0000-0000'`;
let m;

while ((m = regex.exec(str)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (m.index === regex.lastIndex) {
        regex.lastIndex++;
    }
    
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

RegEx

If this expression wasn't desired, it can be modified or changed in regex101.com.

RegEx Circuit

jex.im also helps to visualize the expressions.

---

Edit 1:

In case of (), we want to add two negative lookbehind to our initial expression. Maybe, similar to this:

\(?[0-9]{2,3}\)?(\s|-)[0-9]{4,5}-?[0-9]{3,4}

Answer 4

I believe you can use the following regular expression.

R = /
    \A            # match beginning of string
    (?:           # begin a non-capture group
      \(0?\d{2}\) # match '(' then an optional `0` then two digits then ')'
    |             # or
      0?\d{2}     # match an optional `0` then two digits
    )             # end the non-capture group
    (?:           # begin a non-capture group
      [ ]+        # match one or more spaces
    |             # or
      -           # match a hyphen
    )             # end the non-capture group
    \d{4,5}       # match 4 or 5 digits
    -?            # optionally match a hyphen
    \d{4}         # match 4 digits
    \z            # match end of string
    /x            # free-spacing regex definition mode

arr = [
  '00 00000000',
  '000-000000000',
  '000 00000-0000',
  '00 0000-0000',
  '(00) 0000-0000',
  '(000) 000000000',
  '(000 000000000',
  '(0000) 000000000'
]

arr.map { |s| s.match? R }
  #=> [true, true, true, true, true, true, false, false]

The regex is conventionally written as follows.

R = /\A(?:\(0?\d{2}\)|0?\d{2})(?: +|-)\d{4,5}-?\d{4}\z/

This should be changed as follows if the leading digits cannot equal zero. (If, for example, '001-123456789' and '(12)-023456789' are invalid.)

R = /\A(?:\(0?[1-9]\d\)|0?\[1-9]\d)(?: +|-)[1-9]\d{3,4}-?\d{4}\z/

Answer 5

Don't do this unless you know you are working in a very, very limited scope e.g.

• The numbers are being passed to a system that only accepts a specific format so you know that these exact formats and no others will work
• The numbers are just read by a human, so you can let them figure it out and don't have to validate anything

Otherwise you should use a robust library like https://github.com/mobi/telephone_number (inspired by Google's libphonenumber)