This JavaScript function retrieves the computed value of a specific CSS style property for a given HTML element. It intelligently converts CSS property names from kebab-case to camelCase, which is how they are accessed i...

The `getStyleProperty` function takes an HTML element and a CSS property name. It first validates the inputs. Then, it converts the property name from kebab-case to camelCase using a regular expression replacement. Finally, it uses `window.getComputedStyle(element)` to get the element's current styles and returns the value of the requested property. The time complexity is dominated by `window.getComputedStyle`, which can be O(N) in the worst case (where N is the number of CSS rules affecting the element), but is often much faster in practice. Space complexity is O(1) for the function itself. Edge cases include invalid elements, invalid property names, and properties that are not applicable or set on the element. The correctness is based on the standard DOM `getComputedStyle` API and the reliable camelCase conversion.

function getStyleProperty(element, propertyName): if element is null: return null if propertyName is not a string or is empty: return null camelCaseProperty = convertKebabToCamelCase(propertyName) computedStyle = getComp...

This code provides a utility to find the value of a specific attribute within an HTML element identified by its ID. It first locates the element and then searches its attributes for the requested name. This is useful for...

The `findAttributeValue` function takes an element ID and an attribute name, returning the attribute's value or null if not found. The helper `getAttributeValue` iterates through the `element.attributes` collection. The time complexity is O(N), where N is the number of attributes on the element, as it might need to check every attribute in the worst case. The space complexity is O(1) as it only uses a few variables. Edge cases include a non-existent element ID, an empty attribute name, or an element with no attributes. The correctness relies on the standard DOM API for accessing attributes and the loop correctly checking each attribute's name.

function findAttributeValue(elementId, attributeName): element = getElementById(elementId) if element is null: return null return getAttributeValue(element, attributeName) function getAttributeValue(element, attributeNam...

This JavaScript code defines a function to determine if a given HTML element possesses a specific CSS class. It leverages the `classList` API for efficient checking. This is a fundamental operation in front-end developme...

The `hasSpecificClass` function checks if an element contains a given class name. It first validates the input `element` and `className`. If valid, it uses the `element.classList.contains(className)` method, which is optimized for this purpose. The time complexity is typically O(1) on average for `classList.contains`, as it uses an internal hash-like structure. In the worst case, it could be O(K) where K is the number of classes on the element, though browser implementations are highly optimized. Space complexity is O(1). Edge cases include invalid element references, non-string or empty class names, and elements with no classes. The correctness is guaranteed by the browser's implementation of the `classList` API.

function hasSpecificClass(element, className): if element is null or element.classList is undefined: return false if className is not a string or className is empty: return false return element.classList contains classNa...

This JavaScript code defines a recursive function to extract all textual content from an HTML element and its nested children. It traverses the DOM tree, collecting text nodes and concatenating their values. This is comm...

The `extractTextContent` function uses recursion to traverse the DOM. The base case is when `element` is null or undefined, returning an empty string. For text nodes, it appends their `nodeValue`. For element nodes, it iterates through `childNodes` and recursively calls itself. A space is added between content from different child elements to improve readability. The time complexity is O(N), where N is the total number of nodes (elements and text nodes) in the subtree rooted at the given element. The space complexity is O(H) due to the recursion stack, where H is the height of the DOM subtree. Edge cases include empty elements, elements with only other elements, and elements with mixed text and element children. The algorithm's correctness stems from its exhaustive traversal of all text nodes within the specified element's hierarchy.

function extractTextContent(element): if element is null: return "" text = "" if element is a text node: text = element.nodeValue.trim() else if element is an element node: for each childNode in element.childNodes: text...

This algorithm counts the occurrences of a specific HTML tag within a given HTML document string. It parses the HTML content into a document object and then utilizes the browser's built-in `getElementsByTagName` method t...

The `processHtmlForTagCount` function first validates its inputs to ensure valid HTML content and a non-empty tag name are provided. It then uses `DOMParser` to convert the HTML string into a manipulable `Document` object. The core logic resides in `countElementsByTagName`, which calls `doc.getElementsByTagName(tagName)`. This method returns an `HTMLCollection` of all elements with the specified tag name. The function then iterates through this collection, incrementing a counter for each element found. The time complexity is dominated by `getElementsByTagName`, which is typically O(N) where N is the total number of nodes in the DOM tree, as it needs to traverse the tree. The space complexity is O(M) in the worst case, where M is the number of matching elements, to store the `HTMLCollection`. Edge cases handled include invalid input strings and the absence of the target tag, returning 0 in the latter case.

function processHtmlForTagCount(htmlString, tagName): if htmlString is invalid or tagName is invalid: return error indicator parse htmlString into a document object get all elements with tagName from the document initial...

This algorithm calculates the sum of numeric values of a specified attribute across all HTML elements matching a given tag name. It parses the HTML, finds all relevant elements, extracts the attribute value, converts it...

The `processHtmlForAttributeSum` function validates the target tag and attribute names and then parses the HTML content into a `Document` object. The `sumAttributeValues` function iterates through all elements of the specified `tagName` using `doc.getElementsByTagName`. For each element, it retrieves the `attributeName` using `element.getAttribute`. If the attribute exists, it attempts to convert its value to a floating-point number using `parseFloat`. It then checks if the result is a valid number using `!isNaN()`. If it is, the numeric value is added to `totalSum`. The time complexity is O(N) due to DOM traversal, where N is the total number of nodes. Space complexity is O(M) for the `HTMLCollection`, where M is the number of matching tags. Edge cases handled include missing attributes, non-numeric attribute values, non-existent tags, and invalid input strings.

function sumAttributeValues(document, tagName, attributeName): total_sum = 0 get all elements with tagName from document for each element found: attribute_value = get attribute_name from element if attribute_value is not...

This algorithm extracts the value of a specified attribute from the first HTML element that matches a given tag name. It parses the HTML, finds the first instance of the tag, and then retrieves the attribute's value. Thi...

The `getFirstAttributeValue` function begins with robust input validation, checking for valid HTML content, tag name, and attribute name. It then parses the HTML string into a `Document` object using `DOMParser`. `doc.getElementsByTagName(tagName)` is used to find all elements of the specified tag. If no elements are found (`elements.length === 0`), it returns `null`. Otherwise, it takes the first element (`elements[0]`) and uses `firstElement.getAttribute(attributeName)` to retrieve the attribute's value. If the attribute does not exist on the element, `getAttribute` returns `null`, which is then returned by the function. The time complexity is O(N) due to the DOM traversal by `getElementsByTagName`, where N is the total number of nodes. Space complexity is O(M) for the `HTMLCollection`, where M is the number of matching tags. Edge cases include missing tags, missing attributes, and invalid inputs.

function getFirstAttributeValue(htmlString, tagName, attributeName): validate htmlString, tagName, attributeName parse htmlString into document find all elements with tagName if no elements found: return null get the fir...

This algorithm concatenates the text content of all descendant elements within a given HTML element, including the element itself. It traverses the DOM tree recursively, collecting text nodes and combining them into a si...

The `extractAllTextFromHtml` function parses the input HTML string into a `Document` object and targets the `<body>` element. The core logic is in the recursive `concatenateTextContent` function. It checks if the current `element` is valid. If the element has `textContent`, it's trimmed and appended to the `text` string, followed by a space. The function then iterates through all direct children of the current element, recursively calling `concatenateTextContent` on each child and appending the result to the `text` string. Finally, the accumulated `text` is trimmed of leading/trailing whitespace and returned. The time complexity is O(N), where N is the total number of nodes in the DOM tree, as each node is visited once. The space complexity is O(D) due to the recursion call stack, where D is the maximum depth of the tree. Edge cases include empty HTML, missing `<body>` tags, and elements with no text content.

function concatenateTextContent(element): if element is null: return empty string text = "" if element has text content: text = text + trim(element.textContent) + " " for each child of element: text = text + concatenateT...