Skip to content
Related Articles

Related Articles

How to validate a domain name using Regular Expression
  • Last Updated : 04 Feb, 2021

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. contribute.geeksforgeeks.org).

Examples: 

Input: str = “contribute.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 = "contribute.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 = "contribute.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 = "contribute.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))
 
# This code is contributed by avanitrachhadiya2155
Output: 
true
true
false
false
false

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :