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:
 

#include <iostream>
#include <regex>
using namespace std;

// Function to validate the domain name
bool isValidDomain(const string &str)
{
    // Regex to check valid Domain Name
    regex pattern("^[A-Za-z0-9-]{1,63}\\.[A-Za-z]{2,6}$");

    // Return true if the string matches the regex
    return regex_match(str, pattern);
}

// Driver Code
int main()
{
    // Test Case 1:
    string str1 = "geeksforgeeks.org";
    cout << (isValidDomain(str1) ? "true" : "false") << endl;

    // Test Case 2:
    string str2 = "contribute.geeksforgeeks.org";
    cout << (isValidDomain(str2) ? "true" : "false") << endl;

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

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

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

    return 0;
}

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DomainValidator {

    // Function to validate the 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}$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

        // Return true if the string matches the regex
        return matcher.matches();
    }

    public static void main(String[] args)
    {
        // Test Case 1:
        String str1 = "geeksforgeeks.org";
        System.out.println(
            isValidDomain(str1)); // Expected output: true

        // Test Case 2:
        String str2 = "contribute.geeksforgeeks.org";
        System.out.println(
            isValidDomain(str2)); // Expected output: true

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

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

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

import re

# Function to validate the domain name


def is_valid_domain(s):
    # Regex to check valid Domain Name
    pattern = r"^[A-Za-z0-9-]{1,63}\.[A-Za-z]{2,6}$"

    # Return true if the string matches the regex
    return bool(re.match(pattern, s))


# Driver Code
# Test Case 1:
str1 = "geeksforgeeks.org"
print(is_valid_domain(str1))  # Expected output: True

# Test Case 2:
str2 = "contribute.geeksforgeeks.org"
print(is_valid_domain(str2))  # Expected output: True

# Test Case 3:
str3 = "-geeksforgeeks.org"
print(is_valid_domain(str3))  # Expected output: False

# Test Case 4:
str4 = "geeksforgeeks.o"
print(is_valid_domain(str4))  # Expected output: False

# Test Case 5:
str5 = ".org"
print(is_valid_domain(str5))  # Expected output: False

using System;
using System.Text.RegularExpressions;

class DomainValidator {
    // Function to validate the domain name
    public static bool IsValidDomain(string str)
    {
        // Regex to check valid Domain Name
        string pattern
            = @"^[A-Za-z0-9-]{1,63}\.[A-Za-z]{2,6}$";
        Regex regex = new Regex(pattern);

        // Return true if the string matches the regex
        return regex.IsMatch(str);
    }

    static void Main()
    {
        // Test Case 1:
        string str1 = "geeksforgeeks.org";
        Console.WriteLine(
            IsValidDomain(str1)); // Expected output: True

        // Test Case 2:
        string str2 = "contribute.geeksforgeeks.org";
        Console.WriteLine(
            IsValidDomain(str2)); // Expected output: True

        // Test Case 3:
        string str3 = "-geeksforgeeks.org";
        Console.WriteLine(
            IsValidDomain(str3)); // Expected output: False

        // Test Case 4:
        string str4 = "geeksforgeeks.o";
        Console.WriteLine(
            IsValidDomain(str4)); // Expected output: False

        // Test Case 5:
        string str5 = ".org";
        Console.WriteLine(
            IsValidDomain(str5)); // Expected output: False
    }
}

// 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 = /^[A-Za-z0-9-]{1,63}\.[A-Za-z]{2,6}$/;

    // Check if the string is null or empty
    if (!str) {
        return "false";
    }

    // Return true if the string matches the regex
    return regex.test(str) ? "true" : "false";
}

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

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

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

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

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

true
false
true
false
false

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

prashant_srivastava

Follow

Improve

Article Tags :

• DSA
• Pattern Searching
• Strings
• CPP-regex
• java-regular-expression
• regular-expression

+2 More

Practice Tags :

• Pattern Searching
• Strings