Skip to content
Related Articles
Open in App
Not now

Related Articles

Validate localhost API request processed by POSTMAN using Regular Expression

Improve Article
Save Article
  • Last Updated : 24 Jan, 2023
Improve Article
Save Article

Given some Postman APIs, the task is to check if they are valid or not using regular expressions.

Rules for the valid API:

  • It is an alphanumeric String, a combination of alphabets ( ‘a’ to ‘z’) and digits (0 to 9).
  • It should always start with HTTP and must contain some special symbols (‘:’, ‘/’)
  • It should not contain any whitespaces.

Examples:

Input: http://localhost:1337/api/products
Output: True

Input: http://localhost:30000/user/kyc
Output: True

Approach: The problem can be solved using a regular expression based on the following idea:

Create a regex pattern to validate the number as written below:   
regex= ^(ht|f)tp(s?)\\:\\/\\/[0-9a-zA-Z]([-.\\w]*[0-9a-zA-Z])*(:(0-9)*)*(\\/?)([a-zA-Z0-9\\-\\.\\?\\, \’\\/\\\\\\+&%\\$#_]*)?$“.

Where,

^ : This indicates the start of the string
? : Represents either that character should be present or not.
[0-9a-zA-Z] : Any character either from digit or alphabet can be included.
$ :End of the string.

Follow the below steps to implement the idea:

  • Create a regex expression for Postman API
  • Use Pattern class to compile the regex formed.
  • Use the matcher function to check whether the API is valid or not.
  • If it is valid, return true. Otherwise, return false.

Below is the code implementation of the above approach:-

C++




// C++ program to validate the
// localhost API request processed by POSTMAN
// using Regular Expression
 
#include <bits/stdc++.h>
#include <regex>
using namespace std;
 
// Function to validate the
// localhost API request processed by POSTMAN
string isValidLocalhost_APIRequest(string str)
{
    // Regex to check valid
    // MICR Code.
    const regex pattern(
        "^(ht|f)tp(s?)\\:\\/\\/"
        "[0-9a-zA-Z]([-.\\w]*[0-9a-zA-Z])*(:(0-9)*)*(\\/"
        "?)([a-zA-Z0-9\\-\\.\\?\\, \'\\/"
        "\\\\\\+&%\\$#_]*)?$");
 
    // If the str
    // is empty return false
    if (str.empty()) {
        return "false";
    }
 
    // Return true if the str
    // matched the ReGex
    if (regex_match(str, pattern)) {
        return "true";
    }
    else {
        return "false";
    }
}
 
// Driver Code
int main()
{
    // Test Case 1:
    string str1 = "http:// localhost:1337/api/products";
    cout << isValidLocalhost_APIRequest(str1) << endl;
 
    // Test Case 2:
    string str2 = "http:// localhost:1337/api/products";
    cout << isValidLocalhost_APIRequest(str2) << endl;
 
    // Test Case 3:
    string str3 = "https:// shiptos.com:8081/booking";
    cout << isValidLocalhost_APIRequest(str3) << endl;
 
    // Test Case 4:
    string str4 = "www.gmail.com";
    cout << isValidLocalhost_APIRequest(str4) << endl;
 
    // Test Case 5:
    string str5 = "http:// localhost:30000/sends/search";
    cout << isValidLocalhost_APIRequest(str5) << endl;
 
    // Test Case 6:
    string str6 = "localhost:8000/students";
    cout << isValidLocalhost_APIRequest(str6) << endl;
 
    return 0;
}


Java




// Java program to validate the
// localhost API request processed by POSTMAN
// using Regular Expression
 
import java.util.regex.*;
 
class GFG {
 
    // Function to validate the
    // localhost API request processed by
    // POSTMAN
    public static boolean
    isValidLocalhost_APIRequest(String str)
    {
 
        // Regex to check valid localhost API
        // request
        String regex
            = "^(ht|f)tp(s?)\\:\\/\\/[0-9a-zA-Z]([-.\\w]"
              + "*[0-9a-zA-Z])*(:(0-9)*)*(\\/?)([a-zA-Z0-9\\"
              + "-\\.\\?\\, \'\\/\\\\\\+&%\\$#_]*)?$";
 
        // Compile the ReGex
        Pattern p = Pattern.compile(regex);
 
        // If the str
        // is empty return false
        if (str == null) {
            return false;
        }
 
        // Pattern class contains matcher()
        // method to find matching between
        // given Postman API request using regex.
        Matcher m = p.matcher(str);
 
        // Return if the str
        // matched the ReGex
        return m.matches();
    }
 
    // Driver code
    public static void main(String args[])
    {
        // Test Case 1:
        String str1 = "http:/"
                      + "/localhost:8082/api/secure";
        System.out.println(
            isValidLocalhost_APIRequest(str1));
 
        // Test Case 2:
        String str2 = "http:/"
                      + "/localhost:1337/api/products";
        System.out.println(
            isValidLocalhost_APIRequest(str2));
 
        // Test Case 3:
        String str3 = "https:/"
                      + "/shiptos.com:8081/booking";
        System.out.println(
            isValidLocalhost_APIRequest(str3));
 
        // Test Case 4:
        String str4 = "www.gmail.com";
        System.out.println(
            isValidLocalhost_APIRequest(str4));
 
        // Test Case 5:
        String str5 = "http:/"
                      + "/localhost:30000/sends/search";
        System.out.println(
            isValidLocalhost_APIRequest(str5));
 
        // Test Case 6:
        String str6 = "localhost:8000/students";
        System.out.println(
            isValidLocalhost_APIRequest(str6));
    }
}


Python3




# Python3 program to validate
# localhost API request processed by POSTMAN
# using Regular Expression
 
import re
 
 
# Function to validate
# localhost API request processed by POSTMAN
def isValidLocalhost_APIRequest(str):
 
    # Regex to check valid localhost API request
    # processed by POSTMAN
    regex = "^(ht|f)tp(s?)\\:\\/\\/[0-9a-zA-Z]([-.\\w]"\
    "*[0-9a-zA-Z])*(:(0-9)*)*(\\/?)([a-zA-Z0-9\\-\\.\\"\
    "?\\, \'\\/\\\\\\+&%\\$#_]*)?$"
 
    # 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
if __name__ == '__main__':
     
    # Test Case 1:
    str1 = "http://localhost:8082 / api / secure"
    print(isValidLocalhost_APIRequest(str1))
     
    # Test Case 2:
    str2 = "http://localhost:1337 / api / products"
    print(isValidLocalhost_APIRequest(str2))
     
    # Test Case 3:
    str3 = "https://shiptos.com:8081 / booking"
    print(isValidLocalhost_APIRequest(str3))
     
    # Test Case 4:
    str4 = "www.gmail.com"
    print(isValidLocalhost_APIRequest(str4))
     
    # Test Case 5:
    str5 = "http://localhost:30000 / sends / search"
    print(isValidLocalhost_APIRequest(str5))
     
    # Test Case 6:
    str6 = "localhost:8000 / students"
    print(isValidLocalhost_APIRequest(str6))


C#




// C# program to validate the
// localhost API request processed by POSTMAN
// using Regular Expression
using System;
using System.Text.RegularExpressions;
 
public class GFG{
 
  // Function to validate the
  // LEI Code
  public static bool isValidLocalhost_APIRequest(String str)
  {
 
    // Regex to check valid localhost API
    // request
    var regex = new Regex("^(ht|f)tp(s?)\\:\\/\\/[0-9a-zA-Z]([-.\\w]"
                          + "*[0-9a-zA-Z])*(:(0-9)*)*(\\/?)([a-zA-Z0-9\\"
                          + "-\\.\\?\\, \'\\/\\\\\\+&%\\$#_]*)?$");
 
    // If the str
    // is empty return false
    if (str == null)
    {
      return false;
    }
 
    // Pattern class contains matcher()
    // method to find matching between
    // given Postman API request using regex.
    var m = regex.Match(str);
 
    // Return if the str
    // matched the ReGex
    return m.Success;
  }
 
  // Driver Code.
  public static void Main(String[] args)
  {
 
    // Test Case 1:
    var str1 = "http:/" + "/localhost:8082/api/secure";
    Console.WriteLine(GFG.isValidLocalhost_APIRequest(str1));
 
    // Test Case 2:
    var str2 =  "http:/"+ "/localhost:1337/api/products";
    Console.WriteLine(GFG.isValidLocalhost_APIRequest(str2));
 
    // Test Case 3:
    var str3 = "https:/" + "/shiptos.com:8081/booking";
    Console.WriteLine(GFG.isValidLocalhost_APIRequest(str3));
 
    // Test Case 4:
    var str4 = "www.gmail.com";
    Console.WriteLine(GFG.isValidLocalhost_APIRequest(str4));
 
    // Test Case 5:
    var str5 = "http:/" + "/localhost:30000/sends/search";
    Console.WriteLine(GFG.isValidLocalhost_APIRequest(str5));
 
    // Test Case 6:
    var str6 =  "localhost:8000/students";
    Console.WriteLine(GFG.isValidLocalhost_APIRequest(str6));
  }
}
 
// This code is contributed by Potta Lokesh


Javascript




// Javascript program to validate the
// localhost API request processed by POSTMAN
// using Regular Expression
 
 
// Function to validate the
// localhost API request processed by POSTMAN
function isValidLocalhost_APIRequest(str)
{
    // Regex to check valid
    // MICR Code.
    let regex = new RegExp("^(ht|f)tp(s?)\\:\\/\\/[0-9a-zA-Z]([-.\\w]*[0-9a-zA-Z])*(:(0-9)*)*(\\/?)([a-zA-Z0-9\\-\\.\\?\\, \’\\/\\\\\\+&%\\$#_]*)?$");
    // If the 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 = "http:// localhost:1337/api/products";
    console.log(isValidLocalhost_APIRequest(str1)+"<br>");
 
    // Test Case 2:
    let str2 = "http:// localhost:1337/api/products";
    console.log(isValidLocalhost_APIRequest(str2)+"<br>");
 
    // Test Case 3:
    let str3 = "https:// shiptos.com:8081/booking";
    console.log(isValidLocalhost_APIRequest(str3)+"<br>");
 
    // Test Case 4:
    let str4 = "www.gmail.com";
    console.log(isValidLocalhost_APIRequest(str4)+"<br>");
 
    // Test Case 5:
    let str5 = "http:// localhost:30000/sends/search";
    console.log(isValidLocalhost_APIRequest(str5)+"<br>");
 
    // Test Case 6:
    let str6 = "localhost:8000/students";
    console.log(isValidLocalhost_APIRequest(str6)+"<br>");
 
    // This code is contributed by Utkarsh


Output

true
true
true
false
true
false

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

Related Articles:


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!