How does this regex for FQDNs (excluding.arpa) work?

Question

I am trying to understand how regex works. I understand it little by little. However, I don't understand this one completely. It's basically a regex for fully qualified domain names but a requirement is that the ending can't be .arpa.

(?=^.{4,253}$)(^([a-zA-Z0-9]{1,63}\.)+[a-zA-Z]{2,63}[^.arpa]$)

https://regex101.com/r/hU6tP0/3

This doesn't match google.uk. If I change it to:

(?=^.{4,253}$)(^([a-zA-Z0-9]{1,63}\.)+[a-zA-Z]{1,63}[^.arpa]$)

It works again.

But this works as well

(?=^.{4,253}$)(^([a-zA-Z0-9]{1,63}\.)+[a-zA-Z]{2,63}$)

Here is my thought process for

?=^.{4,253}$)(^([a-zA-Z0-9]{1,63}\.)+[a-zA-Z]{2,63}[^.arpa]$)

I see it as this

(?=

Is a positive look ahead (Can someone explain to me what this actually means?) As I understand it now, it just means that the string needs to match the regex.

^.{4,253}$)

Match all characters but it needs to be between 4 and 253 characters long.

(^([a-zA-Z0-9]{1,63}\.)

Start a capture group and make another capture group within. This capture group says that every non special character can be written 1 to 63 times or till the . is written.

+

The previous capture group can be repeated indefinitely, but it should always end with a .. This way the next capture group is started.

[a-zA-Z]{2,63}

Then as many times as you want you can write a to z with upper, but it needs to be between 2 and 63.

[^.arpa]$)

The last characters can't be .arpa.

Can someone tell me where I am going wrong?

Answer 1

This is an analysis of your regex:

(?=^.{4,253}$)              # force min length: 4 chars, max length: 253 chars
(                           # Capturing Group 1 (CG1) - not needed
    ^                       # Match start of the string
    (                       # CG2 (can be a non capturing group '(?:...)')
      [a-zA-Z0-9]{1,63}     # any sequence of letters and numbers with length between 1 and 63
      \.                    # a literal dot
    )+                      # CLOSE CG2
    [a-zA-Z]{1,63}          # any letter sequence with length between 1 to 63 
    [^.arpa]                # a negated char class: any char that is not a "literal" '.','a','r','p' (last 'a' is redundant)
  $                         # end of the string
)                           # CLOSE CG1

To avoid the tail of the string to be .arpa you need to use a negative lookahead (?!...), so modify just like this:

(?=^.{4,253}$)(?!.*\.arpa$)(^([a-zA-Z0-9]{1,63}\.)+[a-zA-Z]{2,63}$)

An online demo

Update:

I've upgraded the regex to rationalise it (i've incorporated also the Sobrique suggestion adding an important details):

 /^(?=.{4,253}$)([a-z0-9]{1,63}[.])+(?!arpa$)[a-z]{2,63}$/i

Compact version online demo

Legenda

/                     # js regex delimiter
 ^                    # start of the string
   (?=.{4,253}$)      # force min length: 4 chars, max length: 253 chars
   (?:                # Non capturing group 1 (NCG1)
     [a-z0-9]{1,63}   # any letter or digit in a sequence with length from 1 to 63 chars
     [.]              # a literal dot '.' (more readable than \.)
   )+                 # CLOSE NCG1 - repeat its content one or more time
   (?!arpa$)          # force that after the last literal dot '.' the string does not end with 'arpa' (i've added '$' to Sobrique suggestion instead it prevents also '.arpanet' too)
   [a-z]{2,63}        # a sequence of letters with length from 2 to 63
 $                    # end of the string
/i                    # Close the regex delimiter and add case insensitive flag [a-z] match also [A-Z] and viceversa

var re = /^(?=.{4,253}$)([a-z0-9]{1,63}[.])+(?!arpa$)[a-z]{2,63}$/i;

var tests = ['google.uk','domain.arpa','domain.arpa2','another.domain.arpa.net','domain.arpanet'];
var m;

while(t = tests.pop()) {
    document.getElementById("r").innerHTML += '"' + t + '"<br/>';
    document.getElementById("r").innerHTML += 'Valid domain? ' + ( (t.match(re)) ? '<font color="green">YES</font>' : '<font color="red">NO</font>') + '<br/><br/>';
}
    

<div id="r"/>

Answer 2

This doesn't do what you think it does:

[^.arpa]

All that says is 'ends with something that isn't one of the letter apr.' - it's a negated character class.

You might be thinking of a negative lookahead assertion:

(?!\.arpa)$

But if you're trying to compound multiple criteria in a regex, I'd suggest you're probably using the wrong tool for the job. It ends up complicated and hard to debug, thanks to greedy/non-greedy matching, etc.

Your 'positive/negative' lookaheads are to match a piece of a pattern that aren't surrounded by other pieces of pattern. But that can have some unexpected outcomes if you're matching variable widths, because the regex engine will backtrack until it finds something that matches.

A simpler example:

([\w.]+)(?!arpa)$

Applied to:

www.test.arpa

Will it match? What's in the group?

... it will match, because [\w\.]+ will consume all of it, and then the lookahead won't "see" anything.

If you use:

([\w]+)\.(?!arpa)

Instead though - you'll capture.... www, but you won't match test (with e.g. g flag, because the www doesn't have .arpa after it, but the test does.

https://regex101.com/r/hU6tP0/5

It really does get complicated using negative assertions in a pattern as a result. I'd suggest simply not doing so, and applying two separate tests. It's hard for you to figure out, and it's hard for a future maintenance programmer too!