HTML Entity Parser
Last Updated :
01 Apr, 2024
Given a string str which has various HTML Entities in it, the task is to replace these entities with their corresponding special character.
HTML entity parser is the parser that takes HTML code as input and replaces all the entities of the special characters by the characters itself. The special characters and their entities for HTML are Quotation Mark: the entity is “, and symbol character is “.
Below is the HTML Entities with their corresponding special characters are shown in the table below:
| Name/ Description | HTML Entity | Special Character |
|---|
| Space | | |
| Ampersand | & | & |
| Greater than | > | > |
| Less than | < | < |
| Single Quotation Mark | ' | ‘ |
| Double Quotation Mark | " | “ |
| Trademark | ® | ® |
| Copyright mark | © | © |
| Forward Slash | ⁄ | ? |
Examples:
Input: str = “17 > 25 and 25 < 17”
Output: 17 > 25 and 25 < 17
Explanation: In the above example > is replaced by corresponding special character > and < is replaced by <
Input: str = “© is symbol of copyright”
Output: © is symbol of copyright
Explanation: In the above example © is replaced by corresponding special character ©
Method 1 – using unordered_map: Below are the steps:
- Store the HTML Entity with their character in a Map.
- Traverse the given string and if any character ‘&’ is encountered then find which HTML Entity is present after this ampersand.
- Add the corresponding character with the Entity in the output string.
- Print the output string as the result.
Below is the implementation of the above approach:
Java
import java.util.HashMap;
import java.util.Map;
// Java program for the above approach
public class HtmlEntityParser {
public static Map<String, String> map = new HashMap<>();
static {
// Associating html entity with
// special character
map.put(""", "\"");
map.put("'", "'");
map.put("&", "&");
map.put(">", ">");
map.put("<", "<");
map.put("⁄", "/");
map.put(" ", " ");
map.put("®", "®");
map.put("©", "©");
}
// Function that convert the given
// HTML Entity to its parsed String
public static String parseInputString(String input) {
// Output string
StringBuilder output = new StringBuilder();
// Traverse the input string
for (int i = 0; i < input.length(); i++) {
// If any ampersand is occurred
if (input.charAt(i) == '&') {
StringBuilder buffer = new StringBuilder();
while (i < input.length()) {
buffer.append(input.charAt(i));
// If any ampersand is occurred
if (input.charAt(i) == ';' && map.containsKey(buffer.toString())) {
// Append the parsed
// character
output.append(map.get(buffer.toString()));
buffer.setLength(0);
i++;
break;
} else {
i++;
}
}
if (i >= input.length()) {
output.append(buffer);
break;
}
i--;
} else {
output.append(input.charAt(i));
}
}
// convert the string builder into string
// return the answer.
return output.toString();
}
public static void main(String[] args) {
// Initialize the parse string
String input = "17 > 25 and 25 < 17";
// Function call
System.out.println(parseInputString(input));
}
}
// C# program for the above approach
using System;
using System.Collections.Generic;
public class HtmlEntityParser {
public static Dictionary<string, string> map = new Dictionary<string, string>()
{
// Associating html entity with
// special character
{ """, "\"" },
{ "'", "'" },
{ "&", "&" },
{ ">", ">" },
{ "<", "<" },
{ "⁄", "/" },
{ " ", " " },
{ "®", "®" },
{ "©", "©" }
};
// Function that convert the given
// HTML Entity to its parsed String
public static string ParseInputString(string input)
{
// Output string
var output = new System.Text.StringBuilder();
// Traverse the input string
for (int i = 0; i < input.Length; i++)
{
// If any ampersand is occurred
if (input[i] == '&')
{
var buffer = new System.Text.StringBuilder();
while (i < input.Length)
{
buffer.Append(input[i]);
// If any ampersand is occurred
if (input[i] == ';' && map.ContainsKey(buffer.ToString()))
{
// Append the parsed
// character
output.Append(map[buffer.ToString()]);
buffer.Length = 0;
i++;
break;
}
else
{
i++;
}
}
if (i >= input.Length)
{
output.Append(buffer);
break;
}
i--;
}
else
{
output.Append(input[i]);
}
}
// convert the string builder into string
// return the answer.
return output.ToString();
}
public static void Main(string[] args)
{
// Initialize the parse string
string input = "17 > 25 and 25 < 17";
// Function call
Console.WriteLine(ParseInputString(input));
}
}
// Contributed by adityasharmadev01
// JavaScript program for the above approach
class GfG {
constructor() {
this.m = {};
}
// Associating html entity with special character
initializeMap() {
this.m["""] = "\"";
this.m["'"] = "'";
this.m["&"] = "&";
this.m[">"] = ">";
this.m["<"] = "<";
this.m["⁄"] = "/";
this.m[" "] = " ";
this.m["®"] = "®";
this.m["©"] = "©";
}
// Function that convert the given
// HTML Entity to its parsed String
parseInputString(input) {
// Output string
let output = "";
// Traverse the string
let i = 0;
while (i < input.length) {
// If any ampersand is occurred
if (input[i] === '&') {
let buffer = "";
while (i < input.length) {
buffer += input[i];
// If any semicolon is occurred
if (input[i] === ';' && this.m[buffer]) {
// Append the parsed character
output += this.m[buffer];
// Clear the buffer
buffer = "";
i++;
break;
} else {
i++;
}
}
if (i >= input.length) {
output += buffer;
break;
}
i--;
} else {
output += input[i];
}
i++;
}
// Return the parsed string
return output;
}
}
// Driver Code
// Given String
const input_str = "17 > 25 and 25 < 17";
const g = new GfG();
// Initialised parsed string
g.initializeMap();
// Function Call
console.log(g.parseInputString(input_str));
// C++ program for the above approach
#include <iostream>
#include <unordered_map>
using namespace std;
class GfG {
public:
unordered_map<string, string> m;
public:
// Associating html entity with
// special character
void initializeMap()
{
m["""] = "\"";
m["'"] = "'";
m["&"] = "&";
m[">"] = ">";
m["<"] = "<";
m["⁄"] = "/";
m[" "] = " ";
m["®"] = "®";
m["©"] = "©";
}
public:
// Function that convert the given
// HTML Entity to its parsed String
string parseInputString(string input)
{
// Output string
string output = "";
// Traverse the string
for (int i = 0;
i < input.size(); i++) {
// If any ampersand is occurred
if (input[i] == '&') {
string buffer;
while (i < input.size()) {
buffer = buffer + input[i];
// If any ampersand is occurred
if (input[i] == ';'
&& m.find(buffer)
!= m.end()) {
// Append the parsed
// character
output = output
+ m[buffer];
// Clear the buffer
buffer = "";
i++;
break;
}
else {
i++;
}
}
if (i >= input.size()) {
output = output
+ buffer;
break;
}
i--;
}
else {
output = output
+ input[i];
}
}
// Return the parsed string
return output;
}
};
// Driver Code
int main()
{
// Given String
string input = "17 > 25 and 25 < 17";
GfG g;
// Initialised parsed string
g.initializeMap();
// Function Call
cout << g.parseInputString(input);
return 0;
}
# Python program for the above approach
class GfG:
def __init__(self):
self.m = {}
# Associating html entity with special character
def initializeMap(self):
self.m["""] = "\""
self.m["'"] = "'"
self.m["&"] = "&"
self.m[">"] = ">"
self.m["<"] = "<"
self.m["⁄"] = "/"
self.m[" "] = " "
self.m["®"] = "®"
self.m["©"] = "©"
# Function that convert the given
# HTML Entity to its parsed String
def parseInputString(self, input):
# Output string
output = ""
# Traverse the string
i = 0
while i < len(input):
# If any ampersand is occurred
if input[i] == '&':
buffer = ""
while i < len(input):
buffer = buffer + input[i]
# If any semicolon is occurred
if input[i] == ';' and buffer in self.m:
# Append the parsed character
output = output + self.m[buffer]
# Clear the buffer
buffer = ""
i += 1
break
else:
i += 1
if i >= len(input):
output = output + buffer
break
i -= 1
else:
output = output + input[i]
i += 1
# Return the parsed string
return output
# Driver Code
if __name__ == '__main__':
# Given String
input_str = "17 > 25 and 25 < 17"
g = GfG()
# Initialised parsed string
g.initializeMap()
# Function Call
print(g.parseInputString(input_str))
# Contributed by adityasha4x71
Output17 > 25 and 25 < 17
Time Complexity: O(N)
Auxiliary Space: O(N)
Method 2 – using Pattern Matching: Below are the steps:
- Traverse the given string str.
- While traversing, if any character ‘&’ is encountered then find which HTML Entity is present after this ampersand.
- Add the corresponding character with the Entity in the output string from the above table of matched character in the above table.
- Print the output string as the result after traversing the above string.
Below is the implementation of the above approach:
Java
public class GfG {
public String parseInputString(String input) {
// To store parsed string
StringBuilder output = new StringBuilder();
int i = 0;
while (i < input.length()) {
// Matching pattern of html entity
if (input.charAt(i) == '&') {
StringBuilder buffer = new StringBuilder();
while (i < input.length()) {
buffer.append(input.charAt(i));
if (input.charAt(i) == ';') {
if (buffer.toString().equals(""")) {
output.append("\"");
buffer = new StringBuilder();
i++;
break;
} else if (buffer.toString().equals("'")) {
output.append("'");
buffer = new StringBuilder();
i++;
break;
} else if (buffer.toString().equals("&")) {
output.append("&");
buffer = new StringBuilder();
i++;
break;
} else if (buffer.toString().equals(">")) {
output.append(">");
buffer = new StringBuilder();
i++;
break;
} else if (buffer.toString().equals("<")) {
output.append("<");
buffer = new StringBuilder();
i++;
break;
} else if (buffer.toString().equals("⁄")) {
output.append("/");
buffer = new StringBuilder();
i++;
break;
} else if (buffer.toString().equals(" ")) {
output.append(" ");
buffer = new StringBuilder();
i++;
break;
} else if (buffer.toString().equals("®")) {
output.append("®");
buffer = new StringBuilder();
i++;
break;
} else if (buffer.toString().equals("©")) {
output.append("©");
buffer = new StringBuilder();
i++;
break;
} else {
i++;
}
} else {
i++;
}
}
if (i >= input.length()) {
output.append(buffer);
break;
}
i--;
} else {
output.append(input.charAt(i));
}
i++;
}
// Return the parsed string
return output.toString();
}
public static void main(String[] args) {
// Given String
String input = "17 > 25 and 25 < 17";
GfG g = new GfG();
// Function Call
System.out.println(g.parseInputString(input));
}
}
using System;
class GfG
{
// Function to parse the input string containing HTML entities
public string ParseInputString(string input)
{
// To store the parsed string
string output = "";
// Loop through the input string
for (int i = 0; i < input.Length; i++)
{
// Matching pattern of HTML entity
if (input[i] == '&')
{
string buffer = "";
// Loop until the end of the input string
while (i < input.Length)
{
buffer += input[i];
// Check match for (")
if (input[i] == ';' && buffer == """)
{
output += "\"";
buffer = "";
i++;
break;
}
// Check match for (')
else if (input[i] == ';' && buffer == "'")
{
output += "'";
buffer = "";
i++;
break;
}
// Check match for (&)
else if (input[i] == ';' && buffer == "&")
{
output += "&";
buffer = "";
i++;
break;
}
// Check match for (>)
else if (input[i] == ';' && buffer == ">")
{
output += ">";
buffer = "";
i++;
break;
}
// Check match for (<)
else if (input[i] == ';' && buffer == "<")
{
output += "<";
buffer = "";
i++;
break;
}
// Check match for (⁄)
else if (input[i] == ';' && buffer == "⁄")
{
output += "/";
buffer = "";
i++;
break;
}
// If no match is found, increment index
else
{
i++;
}
}
// If reached end of input, add buffer to output
if (i >= input.Length)
{
output += buffer;
break;
}
i--;
}
else
{
// If no match is found, add character to output
output += input[i];
}
}
// Return the parsed string
return output;
}
}
class Program
{
static void Main(string[] args)
{
// Given String
string input = "17 > 25 and 25 < 17";
// Create an instance of GfG class
GfG g = new GfG();
// Function Call
Console.WriteLine(g.ParseInputString(input));
}
}
function parseInputString(input) {
// To store parsed string
let output = '';
let i = 0;
while (i < input.length) {
// Matching pattern of html entity
if (input.charAt(i) === '&') {
let buffer = '';
while (i < input.length) {
buffer += input.charAt(i);
if (input.charAt(i) === ';') {
switch (buffer) {
case '"':
output += '"';
break;
case ''':
output += "'";
break;
case '&':
output += "&";
break;
case '>':
output += ">";
break;
case '<':
output += "<";
break;
case '⁄':
output += "/";
break;
case ' ':
output += " ";
break;
case '®':
output += "®";
break;
case '©':
output += "©";
break;
default:
i++;
continue;
}
i++;
break;
} else {
i++;
}
}
if (i >= input.length) {
output += buffer;
break;
}
i--;
} else {
output += input.charAt(i);
}
i++;
}
// Return the parsed string
return output;
}
// Given String
let input = "17 > 25 and 25 < 17";
// Function Call
console.log(parseInputString(input));
#include <iostream>
using namespace std;
class GfG {
public:
// Function to parse the input string
string parseInputString(string input) {
// To store parsed string
string output = "";
// Loop through the input string
for (int i = 0; i < input.size(); i++) {
// Matching pattern of html entity
if (input[i] == '&') {
string buffer;
// Loop until the end of the input string
while (i < input.size()) {
buffer = buffer + input[i];
// Check match for (")
if (input[i] == ';' && buffer == """) {
output = output + "\"";
buffer = "";
i++;
break;
}
// Check match for (')
else if (input[i] == ';' && buffer == "'") {
output = output + "'";
buffer = "";
i++;
break;
}
// Check match for (&)
else if (input[i] == ';' && buffer == "&") {
output = output + "&";
buffer = "";
i++;
break;
}
// Check match for (>)
else if (input[i] == ';' && buffer == ">") {
output = output + ">";
buffer = "";
i++;
break;
}
// Check match for (<)
else if (input[i] == ';' && buffer == "<") {
output = output + "<";
buffer = "";
i++;
break;
}
// Check match for (⁄)
else if (input[i] == ';' && buffer == "⁄") {
output = output + "/";
buffer = "";
i++;
break;
}
// If no match is found, increment index
else {
i++;
}
}
// If reached end of input, add buffer to output
if (i >= input.size()) {
output = output + buffer;
break;
}
i--;
}
else {
// If no match is found, add character to output
output = output + input[i];
}
}
// Return the parsed string
return output;
}
};
// Driver Code
int main() {
// Given String
string input = "17 > 25 and 25 < 17";
GfG g;
// Function Call
cout << g.parseInputString(input);
return 0;
}
class GfG:
def __init__(self):
# Dictionary to store HTML entities and their corresponding characters
self.html_entities = {
'"': """,
"'": "'",
"&": "&",
">": ">",
"<": "<",
"/": "⁄",
" ": " ",
"®": "®",
"©": "©"
}
def parse_input_string(self, input_str):
"""
Parses the input string by replacing HTML entities with their corresponding characters.
:param input_str: Input string containing HTML entities
:return: Parsed string with replaced characters
"""
output = ""
i = 0
while i < len(input_str):
# Matching pattern of HTML entity
if input_str[i] == '&':
buffer = ""
while i < len(input_str):
buffer += input_str[i]
# Check for each HTML entity and replace with corresponding character
if input_str[i] == ';' and buffer in self.html_entities.values():
output += [key for key, value in self.html_entities.items() if value == buffer][0]
buffer = ""
i += 1
break
else:
i += 1
# If end of string is reached
if i >= len(input_str):
output += buffer
break
i -= 1
else:
output += input_str[i]
i += 1
# Return the parsed string
return output
# Driver Code
if __name__ == "__main__":
# Given String
input_str = "17 > 25 and 25 < 17"
gfg = GfG()
# Function Call
print(gfg.parse_input_string(input_str))
Output17 > 25 and 25 < 17
Time Complexity: O(N)
Auxiliary Space: O(N)
Method 3 – using Regular Expression: Below are the steps:
- Store all the expression with it’s mapped value in a Map M.
- For each key in the map, create a regular expression using:
regex e(key);
- Now replace the above regular expression formed with it’s mapped value in the Map M as:
regex_replace(str, e, value); where, str is the input string, e is the expression formed in the above step, and val is the value mapped with expression e in the Map
- Repeat the above steps until all expression are not replaced.
Below is the implementation of the above approach:
Java
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MainClass {
// Given Expression with mapped value
static Map<String, String> m = new HashMap<String, String>() {{
put(""", "\"");
put("'", "'");
put("&", "&");
put(">", ">");
put("<", "<");
put("⁄", "/");
}};
// Function that converts the given
// HTML Entity to its parsed String
static String parseInputString(String input) {
for (Map.Entry<String, String> entry : m.entrySet()) {
// Create Regex Pattern
String pattern = Pattern.quote(entry.getKey());
// Replace the above pattern
// with mapped value using
// Matcher and replaceAll
input = input.replaceAll(pattern, entry.getValue());
}
// Return the parsed string
return input;
}
// Driver Code
public static void main(String[] args) {
// Given String
String input = "17 > 25 and 25 < 17";
// Function Call
System.out.println(parseInputString(input));
}
}
import re
import sys
# Dictionary mapping HTML entities to their respective characters
m = {
""": "\"",
"'": "'",
"&": "&",
">": ">",
"<": "<",
"⁄": "/"
}
# Function that converts the given HTML Entity to its parsed String
def parse_input_string(input_str):
for key, value in m.items():
# Create Regex Pattern
pattern = re.escape(key)
# Replace the above pattern with mapped value using re.sub
input_str = re.sub(pattern, value, input_str)
# Return the parsed string
return input_str
if __name__ == "__main__":
# Get input string from command line arguments
if len(sys.argv) > 1:
input_str = ' '.join(sys.argv[1:])
else:
# Given default input string
input_str = "17 > 25 and 25 < 17"
# Function Call
print(parse_input_string(input_str))
using System;
using System.Text.RegularExpressions;
using System.Collections.Generic;
public class MainClass
{
// Given Expression with mapped value
static Dictionary<string, string> m = new Dictionary<string, string>
{
{ """, "\"" },
{ "'", "'" },
{ "&", "&" },
{ ">", ">" },
{ "<", "<" },
{ "⁄", "/" }
};
// Function that converts the given
// HTML Entity to its parsed String
static string ParseInputString(string input)
{
foreach (var kvp in m)
{
// Create Regex Pattern
string pattern = Regex.Escape(kvp.Key);
// Replace the above pattern
// with mapped value using
// Regex.Replace
input = Regex.Replace(input, pattern, kvp.Value);
}
// Return the parsed string
return input;
}
// Driver Code
public static void Main(string[] args)
{
// Given String
string input = "17 > 25 and 25 < 17";
// Function Call
Console.WriteLine(ParseInputString(input));
}
}
// Given Expression with mapped value
const m = {
""": "\"", // HTML entity for double quote
"'": "'", // HTML entity for single quote
"&": "&", // HTML entity for ampersand
">": ">", // HTML entity for greater than
"<": "<", // HTML entity for less than
"/": "/" // HTML entity for slash
};
// Function that converts the given
// HTML Entity to its parsed String
function parseInputString(input) {
for (const [key, value] of Object.entries(m)) {
// Create RegExp object with global flag to replace all occurrences
const re = new RegExp(key, 'g');
// Replace the HTML entity with its corresponding value using replaceAll method
input = input.replaceAll(re, value);
}
// Return the parsed string
return input;
}
// Driver Code
const input = "17 > 25 and 25 < 17";
// Function Call
console.log(parseInputString(input));
#include <iostream>
#include <regex>
#include <unordered_map>
using namespace std;
// Given Expression with mapped value
const unordered_map<string, string> m = {
{ """, "\"" }, // HTML entity for double quote
{ "'", "'" }, // HTML entity for single quote
{ "&", "&" }, // HTML entity for ampersand
{ ">", ">" }, // HTML entity for greater than
{ "<", "<" }, // HTML entity for less than
{ "/", "/" } // HTML entity for slash
};
// Function that converts the given
// HTML Entity to its parsed String
string parseInputString(string input)
{
for (auto& it : m) {
// Create ReGex Expression
regex e(it.first);
// Replace the above expression
// with mapped value using
// regex_replace()
input = regex_replace(input, e, it.second);
}
// Return the parsed string
return input;
}
// Driver Code
int main()
{
// Given String
string input = "17 > 25 and 25 < 17";
// Function Call
cout << parseInputString(input);
return 0;
}
Output17 > 25 and 25 < 17
Time Complexity: O(N)
Auxiliary Space: O(N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...