Extracting Port Number from a localhost API Request to a Server using Regular Expressions

Given a String test_str as localhost API Request Address, the task is to get the extract port number of the service.

Examples:

Input: test_str = ‘http://localhost:8109/users/addUsers’
Output: 8109
Explanation: Port Number, 8109 extracted.

Input: test_str = ‘http://localhost:1337/api/products’
Output: 1337
Explanation: Port Number, 1337 extracted.

Approach: The problem can be solved based on the following idea:

Create a regex pattern to validate the number as written below:   
regex = “[:]{1}[0-9]{4, }“

Where,  

• [:]: This pattern will match if one of the preceding is a colon character
• [0-9]{4} : This pattern will allow 4 or more than 4 preceding elements if they are digits.

Follow the below steps to implement the idea:

• Create a regex expression to extract all the Port numbers from the string.
• Use Pattern class to compile the regex formed.
• Use the matcher function to find.

Below is the code implementation of the above-discussed approach:

// C++ code for the above approach:
#include <bits/stdc++.h>
#include <regex>
using namespace std;

// Function to extract the port
// Number from a given string
void extractPortNumber(string str)
{

    // You can Add n number of API and
    // its format to extract port
    // Number formats in the below
    // given String Array.
    string strPattern[] = { "[:]{1}[0-9]{4}" };
    for (int i = 0; i < 1; i++) {
        regex pattern(strPattern[i]);
        smatch matcher;
        if (regex_search(str, matcher, pattern)) {
            cout << matcher.str().substr(1) << endl;
        }
    }
}

// Driver Code
int main()
{
    // String containing the
    // API Request
    string str = "http://localhost:8082/api/secure";
    cout << "Given String is:\n" << str << endl;
    cout << "Above Given API is running on Port Number:\n";
    extractPortNumber(str);
    return 0;
}

// This Code is Contributed by Prasad Kandekar(prasad264)

// Java code for the above approach
import java.io.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class GFG {

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

        // String containing the
        // API Request
        String str = "http:/"
                     + "/localhost:8082/api/secure";
        System.out.println("Given String is:\n" + str);
        System.out.println(
            "Above Given API is running on Port Number:");
        extractPortNumber(str);
    }

    // Function to extract the port
    // Number from a given string
    static void extractPortNumber(String str)
    {

        // You can Add n number of API and
        // its format to extract port
        // Number formats in the below
        // given String Array.
        String strPattern[] = { "[:]{1}[0-9]{4}" };
        for (int i = 0; i < strPattern.length; i++) {
            Pattern pattern
                = Pattern.compile(strPattern[i]);
            Matcher matcher = pattern.matcher(str);
            while (matcher.find()) {
                System.out.println(
                    matcher.group().replace(":", ""));
            }
        }
    }
}

using System;
using System.Text.RegularExpressions;

class GFG {
  static void Main(string[] args)
  {

    // String containing the
    // API Request
    string str = "http:/"
      + "/localhost:8082/api/secure";
    Console.WriteLine("Given String is:\n" + str);
    Console.WriteLine(
      "Above Given API is running on Port Number:");
    ExtractPortNumber(str);
  }

  static void ExtractPortNumber(string str)
  {

    // You can Add n number of API and
    // its format to extract port
    // Number formats in the below
    // given String Array.
    string[] strPattern = { "[:]{1}[0-9]{4}" };
    for (int i = 0; i < strPattern.Length; i++) {
      Regex pattern = new Regex(strPattern[i]);
      MatchCollection matches = pattern.Matches(str);
      foreach(Match match in matches)
      {
        Console.WriteLine(
          match.Value.Replace(":", ""));
      }
    }
  }
}

import re

# Function to extract the port number from a given string
def extractPortNumber(str):
    # You can add n number of API and its format to extract port
    # number formats in the below given String Array.
    strPattern = [r"[:]{1}[0-9]{4}"]
    for pattern in strPattern:
        matches = re.findall(pattern, str)
        for match in matches:
            print(match.replace(":", ""))

# Driver code
if __name__ == "__main__":
    # String containing the API request
    str = "http://localhost:8082/api/secure"
    print("Given String is:\n" + str)
    print("Above Given API is running on Port Number:")
    extractPortNumber(str)

// Function to extract the port
// Number from a given string
function extractPortNumber(str) {

  // You can Add n number of API and
  // its format to extract port
  // Number formats in the below
  // given String Array.
  const strPattern = [ /[:]{1}[0-9]{4}/ ];
  for (let i = 0; i < 1; i++) {
    const pattern = strPattern[i];
    const matcher = str.match(pattern);
    if (matcher) {
      console.log(matcher[0].substr(1));
    }
  }
}

// Driver Code
const str = "http://localhost:8082/api/secure";
console.log("Given String is:\n" + str);
console.log("Above Given API is running on Port Number:\n");
extractPortNumber(str);

Given String is:
http://localhost:8082/api/secure
Above Given API is running on Port Number:
8082

Complexity :

The time complexity of the above  code depends on the size of the input string and the number of patterns in the strPattern array. Since the for loop only iterates once over the strPattern array, the time complexity is O(n), where n is the size of the input string. This is because the regular expression matching operation takes O(n) time in the worst case for an input string of size n.

The space complexity of the above code is also O(n) because it only stores the input string and the regular expression pattern in memory, both of which have a size proportional to n. Additionally, the matcher object created by regex_search has a space complexity that is dependent on the size of the input string, but since it is only used to extract the port number and not stored, it does not contribute to the overall space complexity.

Related Articles:

• Regular Expressions in Java
• Python RegEx
• JavaScript Regular Expressions

rahul_chauhan_1998

Follow

Improve

Article Tags :

• Strings
• Pattern Searching
• DSA
• regular-expression
• strings

+1 More

Practice Tags :

• Pattern Searching
• Strings
• Strings