How to validate a domain name using Regular Expression

Given string str, the task is to check whether the given string is a valid domain name or not by using Regular Expression.
The valid domain name must satisfy the following conditions: 

1. The domain name should be a-z or A-Z or 0-9 and hyphen (-).
2. The domain name should be between 1 and 63 characters long.
3. The domain name should not start or end with a hyphen(-) (e.g. -geeksforgeeks.org or geeksforgeeks.org-).
4. The last TLD (Top level domain) must be at least two characters and a maximum of 6 characters.
5. The domain name can be a subdomain (e.g. write.geeksforgeeks.org).

Examples:

Input: str = “write.geeksforgeeks.org” 
Output: true 
Explanation:
The given string satisfies all the above mentioned conditions. Therefore, it is a valid domain name.
Input: str = “-geeksforgeeks.org” 
Output: false 
Explanation:
The given string starts with a hyphen (-). Therefore, it is not a valid domain name.
Input: str = “geeksforgeeks.o” 
Output: false 
Explanation:
The given string have last TLD of 1 character, the last TLD must be between 2 and 6 characters long. Therefore, it is not a valid domain name.
Input: str = “.org” 
Output: false 
Explanation:
The given string doesn’t start with a-z or A-Z or 0-9. Therefore, it is not a valid domain name. 

Approach: The idea is to use Regular Expression to solve this problem. The following steps can be followed to compute the answer:

• Get the String.
• Create a regular expression to check the valid domain name as mentioned below:

regex = “^((?!-)[A-Za-z0-9-]{1, 63}(?<!-)\\.)+[A-Za-z]{2, 6}$” 

• Where: 
  • ^ represents the starting of the string.
  • ( represents the starting of the group.
  • (?!-) represents the string should not start with a hyphen (-).
  • [A-Za-z0-9-]{1, 63} represents the domain name should be a-z or A-Z or 0-9 and hyphen (-) between 1 and 63 characters long.
  • (?<!-) represents the string should not end with a hyphen (-).
  • \\. represents the string followed by a dot.
  • )+ represents the ending of the group, this group must appear at least 1 time, but allowed multiple times for subdomain.
  • [A-Za-z]{2, 6} represents the TLD must be A-Z or a-z between 2 and 6 characters long.
  • $ represents the ending of the string.
• Match the given string with the regular expression. In Java, this can be done by using Pattern.matcher().
• Return true if the string matches with the given regular expression, else return false.

Below is the implementation of the above approach:

C++

// C++ program to validate the
// domain name using Regular Expression
#include <iostream>
#include <regex>
using namespace std;

// Function to validate the domain name.
bool isValidDomain(string str)
{

  // Regex to check valid domain name.
  const regex pattern("^(?!-)[A-Za-z0-9-]+([\\-\\.]{1}[a-z0-9]+)*\\.[A-Za-z]{2,6}$");

  // If the domain name
  // is empty return false
  if (str.empty())
  {
     return false;
  }

  // Return true if the domain name
  // matched the ReGex
  if(regex_match(str, pattern))
  {
    return true;
  }
  else
  {
    return false;
  }
}

// Driver Code
int main()
{

  // Test Case 1:
  string str1 = "geeksforgeeks.org";
  cout << isValidDomain(str1) << endl;

  // Test Case 2:
  string str2 = "write.geeksforgeeks.org";
  cout << isValidDomain(str2) << endl;

  // Test Case 3:
  string str3 = "-geeksforgeeks.org";
  cout << isValidDomain(str3) << endl;

  // Test Case 4:
  string str4 = "geeksforgeeks.o";
  cout << isValidDomain(str4) << endl;

  // Test Case 5:
  string str5 = ".org";
  cout << isValidDomain(str5) << endl;

  return 0;
}

// This code is contributed by yuvraj_chandra

Java

// Java program to validate domain name.
// using regular expression.

import java.util.regex.*;
class GFG {

    // Function to validate domain name.
    public static boolean isValidDomain(String str)
    {
        // Regex to check valid domain name.
        String regex = "^((?!-)[A-Za-z0-9-]"
                       + "{1,63}(?<!-)\\.)"
                       + "+[A-Za-z]{2,6}";

        // Compile the ReGex
        Pattern p
            = Pattern.compile(regex);

        // If the string is empty
        // return false
        if (str == null) {
            return false;
        }

        // Pattern class contains matcher()
        // method to find the matching
        // between the given string and
        // regular expression.
        Matcher m = p.matcher(str);

        // Return if the string
        // matched the ReGex
        return m.matches();
    }

    // Driver Code
    public static void main(String args[])
    {

        // Test Case 1:
        String str1 = "geeksforgeeks.org";
        System.out.println(isValidDomain(str1));

        // Test Case 2:
        String str2 = "write.geeksforgeeks.org";
        System.out.println(isValidDomain(str2));

        // Test Case 3:
        String str3 = "-geeksforgeeks.org";
        System.out.println(isValidDomain(str3));

        // Test Case 4:
        String str4 = "geeksforgeeks.o";
        System.out.println(isValidDomain(str4));

        // Test Case 5:
        String str5 = ".org";
        System.out.println(isValidDomain(str5));
    }
}

Python3

# Python3 program to validate
# domain name
# using regular expression
import re

# Function to validate
# domain name.
def isValidDomain(str):

    # Regex to check valid
    # domain name.
    regex = "^((?!-)[A-Za-z0-9-]" + "{1,63}(?<!-)\\.)" +"+[A-Za-z]{2,6}"

    # Compile the ReGex
    p = re.compile(regex)

    # If the string is empty
    # return false
    if (str == None):
        return False

    # Return if the string
    # matched the ReGex
    if(re.search(p, str)):
        return True
    else:
        return False

# Driver code

# Test Case 1:
str1 = "geeksforgeeks.org"
print(isValidDomain(str1))

# Test Case 2:
str2 = "write.geeksforgeeks.org"
print(isValidDomain(str2))

# Test Case 3:
str3 = "-geeksforgeeks.org"
print(isValidDomain(str3))

# Test Case 4:
str4 = "geeksforgeeks.o"
print(isValidDomain(str4))

# Test Case 5:
str5 = ".org"
print(isValidDomain(str5))

C#

// C# program to validate domain name.
// using Regular Expressions
using System;
using System.Text.RegularExpressions;
class GFG
{

  // Main Method
  static void Main(string[] args)
  {

    // Input strings to Match
    // Valid Domain Name
    string[] str={"geeksforgeeks.org","write.geeksforgeeks.org","-geeksforgeeks.org","geeksforgeeks.o",
                  ".org"};
    foreach(string s in str) {
      Console.WriteLine( isValidDomain(s) ? "true" : "false");
    }
    Console.ReadKey(); }

  // method containing the regex
  public static bool isValidDomain(string str)
  {
    string strRegex = @"^((?!-)[A-Za-z0-9-]{1,63}(?<!-)\.)+[A-Za-z]{2,6}$";
    Regex re = new Regex(strRegex);
    if (re.IsMatch(str))
      return (true);
    else
      return (false);
  }
}

// This code is contributed by Rahul Chauhan

Javascript

// Javascript program to validate
// domain name using Regular Expression

// Function to validate the
// domain name
function isValidDomain(str) {
    // Regex to check valid
    // Domain Name
    let regex = new RegExp(/^(?!-)[A-Za-z0-9-]+([\-\.]{1}[a-z0-9]+)*\.[A-Za-z]{2,6}$/);

    // if str
    // is empty return false
    if (str == null) {
        return "false";
    }

    // Return true if the str
    // matched the ReGex
    if (regex.test(str) == true) {
        return "true";
    }
    else {
        return "false";
    }
}

// Driver Code
// Test Case 1:
let str1 = "geeksforgeeks.org";
console.log(isValidDomain(str1));

// Test Case 2:
let str2 = "contribute.geeksforgeeks.org";
console.log(isValidDomain(str2));

// Test Case 3:
let str3 = "-geeksforgeeks.org";
console.log(isValidDomain(str3));

// Test Case 4:
let str4 = "geeksforgeeks.o";
console.log(isValidDomain(str4));

// Test Case 5:
let str5 = ".org";
console.log(isValidDomain(str5));

// This code is contributed by Rahul Chauhan

Output:

true
true
false
false
false

Time Complexity: O(N) for each testcase, where N is the length of the given string. 
Auxiliary Space: O(1)