Extracting Port Number from a localhost API Request to a Server using Regular Expressions
Last Updated :
14 Mar, 2023
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++
#include <bits/stdc++.h>
#include <regex>
using namespace std;
void extractPortNumber(string str)
{
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;
}
}
}
int main()
{
cout << "Given String is:\n" << str << endl;
cout << "Above Given API is running on Port Number:\n" ;
extractPortNumber(str);
return 0;
}
|
Java
import java.io.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class GFG {
public static void main(String[] args)
{
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);
}
static void extractPortNumber(String str)
{
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( ":" , "" ));
}
}
}
}
|
C#
using System;
using System.Text.RegularExpressions;
class GFG {
static void Main( string [] args)
{
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)
{
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( ":" , "" ));
}
}
}
}
|
Python3
import re
def extractPortNumber( str ):
strPattern = [r "[:]{1}[0-9]{4}" ]
for pattern in strPattern:
matches = re.findall(pattern, str )
for match in matches:
print (match.replace( ":" , ""))
if __name__ = = "__main__" :
print ( "Given String is:\n" + str )
print ( "Above Given API is running on Port Number:" )
extractPortNumber( str )
|
Javascript
function extractPortNumber(str) {
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));
}
}
}
console.log( "Given String is:\n" + str);
console.log( "Above Given API is running on Port Number:\n" );
extractPortNumber(str);
|
Output
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:
Share your thoughts in the comments
Please Login to comment...