How to validate GUID (Globally Unique Identifier) using Regular Expression

Given string str, the task is to check whether the given string is a valid GUID (Globally Unique Identifier) or not by using Regular Expression.
The valid GUID (Globally Unique Identifier) must specify the following conditions: 

1. It should be a 128-bit number.
2. It should be 36 characters (32 hexadecimal characters and 4 hyphens) long.
3. It should be displayed in five groups separated by hyphens (-).
4. Microsoft GUIDs are sometimes represented with surrounding braces.

Examples: 

Input: str = "123e4567-e89b-12d3-a456-9AC7CBDCEE52" 
Output: true 
Explanation: 
The given string satisfies all the above mentioned conditions. Therefore, it is a valid GUID (Globally Unique Identifier).
Input: str = "123e4567-h89b-12d3-a456-9AC7CBDCEE52" 
Output: false 
Explanation: 
The given string contains 'h', the valid hexadecimal characters should be followed by character from a-f, A-F, and 0-9. Therefore, it is not a valid GUID (Globally Unique Identifier).
Input: str = "123e4567-h89b-12d3-a456" 
Output: false 
Explanation: 
The given string has 20 characters. Therefore, it is not a valid GUID (Globally Unique Identifier). 

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 valid GUID (Globally Unique Identifier) as mentioned below:
   

regex = "^[{]?[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}[}]?$" 

• Where: 
  
  • ^ represents the starting of the string.
  • [{]? represents the '{' character that is optional.
  • [0-9a-fA-F]{8} represents the 8 characters from a-f, A-F, and 0-9.
  • - represents the hyphens.
  • ([0-9a-fA-F]{4}-){3} represents the 4 characters from a-f, A-F, and 0-9 that is repeated 3 times separated by a hyphen (-).
  • [0-9a-fA-F]{12} represents the 12 characters from a-f, A-F, and 0-9.
  • [}]? represents the '}' character that is optional.
  • $ 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++ program to validate the
// GUID (Globally Unique Identifier) using Regular Expression
#include <iostream>
#include <regex>
using namespace std;

// Function to validate the GUID (Globally Unique Identifier).
bool isValidGUID(string str)
{

  // Regex to check valid GUID (Globally Unique Identifier).
  const regex pattern("^[{]?[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}[}]?$");


  // If the GUID (Globally Unique Identifier)
  // is empty return false
  if (str.empty())
  {
     return false;
  }

  // Return true if the GUID (Globally Unique Identifier)
  // matched the ReGex
  if(regex_match(str, pattern))
  {
    return true;
  }
  else
  {
    return false;
  }
}

// Driver Code
int main()
{
  // Test Case 1:
  string str1 = "123e4567-e89b-12d3-a456-9AC7CBDCEE52";
  cout << isValidGUID(str1) << endl;

  // Test Case 2:
  string str2 = "{123e4567-e89b-12d3-a456-9AC7CBDCEE52}";
  cout <<  isValidGUID(str2) << endl;

  // Test Case 3:
  string str3 = "123e4567-h89b-12d3-a456-9AC7CBDCEE52";
  cout <<  isValidGUID(str3) << endl;

  // Test Case 4:
  string str4 = "123e4567-h89b-12d3-a456";
  cout <<  isValidGUID(str4) << endl;

  return 0;
}

// This code is contributed by yuvraj_chandra

// Java program to validate
// GUID (Globally Unique Identifier)
// using regular expression

import java.util.regex.*;

class GFG {

    // Function to validate
    // GUID (Globally Unique Identifier)
    // using regular expression
    public static boolean
    isValidGUID(String str)
    {
        // Regex to check valid
        // GUID (Globally Unique Identifier)
        String regex
            = "^[{]?[0-9a-fA-F]{8}"
              + "-([0-9a-fA-F]{4}-)"
              + "{3}[0-9a-fA-F]{12}[}]?$";

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

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

        // Find match between given string
        // and regular expression
        // uSing Pattern.matcher()

        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 str2
            = "123e4567-e89b-12d3"
              + "-a456-9AC7CBDCEE52";
        System.out.println(
            isValidGUID(str2));

        // Test Case 2:
        String str3
            = "{123e4567-e89b-12d3-"
              + "a456-9AC7CBDCEE52}";
        System.out.println(
            isValidGUID(str3));

        // Test Case 3:
        String str1
            = "123e4567-h89b-12d3-a456"
              + "-9AC7CBDCEE52";
        System.out.println(
            isValidGUID(str1));

        // Test Case 4:
        String str4
            = "123e4567-h89b-12d3-a456";
        System.out.println(
            isValidGUID(str4));
    }
}

# Python3 program to validate 
# GUID (Globally Unique Identifier) 
# using regular expression
import re

# Function to validate GUID 
# (Globally Unique Identifier) 
def isValidGUID(str):

    # Regex to check valid 
    # GUID (Globally Unique Identifier) 
    regex = "^[{]?[0-9a-fA-F]{8}" + "-([0-9a-fA-F]{4}-)" + "{3}[0-9a-fA-F]{12}[}]?$"
        
    # 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 = "123e4567-e89b-12d3" + "-a456-9AC7CBDCEE52"
print(isValidGUID(str1))

# Test Case 2:
str2 = "{123e4567-e89b-12d3-" + "a456-9AC7CBDCEE52}"
print(isValidGUID(str2))

# Test Case 3:
str3 = "123e4567-h89b-12d3-a456" + "-9AC7CBDCEE52"
print(isValidGUID(str3))

# Test Case 4:
str4 = "123e4567-h89b-12d3-a456"
print(isValidGUID(str4))

# This code is contributed by avanitrachhadiya2155

// C# program to validate
// GUID (Globally Unique Identifier) using Regular Expression
using System;
using System.Text.RegularExpressions;
class GFG
{

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

    // Input strings to Match
    //GUID (Globally Unique Identifier) 

    string[] str={"123e4567-e89b-12d3-a456-9AC7CBDCEE52","{123e4567-e89b-12d3-a456-9AC7CBDCEE52}","123e456-h89b-12d3-a456-9AC7CBDCEE52","123e4567-h89b-12d3-a456"};
    foreach(string s in str) {
      Console.WriteLine( isValidGUID(s) ? "true" : "false"); 
    }
    Console.ReadKey(); }

  // method containing the regex
  public static bool isValidGUID(string str)
  {
    string strRegex = @"^[{]?[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}[}]?$";
    Regex re = new Regex(strRegex);
    if (re.IsMatch(str))
      return (true);
    else
      return (false);
  }
}

// This code is contributed by Rahul Chauhan

// Javascript program to validate
// GUID (Globally Unique Identifier) using Regular Expression

// Function to validate the
// GUID  
function isValidGUID(str) {
    // Regex to check valid
    // GUID  
    let regex = new RegExp(/^[{]?[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}[}]?$/);

    // 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 =  "123e4567-e89b-12d3"
              + "-a456-9AC7CBDCEE52";
console.log(isValidGUID(str1));

// Test Case 2:
let str2 = "{123e4567-e89b-12d3-"
              + "a456-9AC7CBDCEE52}";
console.log(isValidGUID(str2));

// Test Case 3:
let str3 =  "123e4567-h89b-12d3-a456"
              + "-9AC7CBDCEE52";
console.log(isValidGUID(str3));

// Test Case 4:
let str4 = "123e4567-h89b-12d3-a456";
console.log(isValidGUID(str4));


// This code is contributed by Rahul Chauhan

true
true
false
false

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

prashant_srivastava

Follow

Improve

Article Tags :

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

+2 More

Practice Tags :

• Pattern Searching
• Strings