Benchmark: html encode 3 - MeasureThat.net

Script Preparation code:

function replaceAllWithShortcut(str) {
    return !(/[<>&"']/.test(str)) ? str :
           str.replaceAll('&', '&amp;').replaceAll('<', '&lt;')
              .replaceAll('>', '&gt;').replaceAll('"', '&quot;');
}

const cachedElementParent = document.createElement('div');
const cachedChildTextNode = document.createTextNode('');
cachedElementParent.appendChild(cachedChildTextNode);

function serializeTextNode(text) {
  cachedChildTextNode.nodeValue = text;
  return cachedElementParent.innerHTML;
}

Tests:

replaceAllWithShortcut
replaceAllWithShortcut("hello world")
serializeTextNode
serializeTextNode("hello world")
replaceAllWithShortcut no tags
replaceAllWithShortcut("hello world")

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
replaceAllWithShortcut
serializeTextNode
replaceAllWithShortcut no tags

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Script Preparation Code**

The script preparation code defines two functions:

1. `replaceAllWithShortcut(str)`: This function replaces special characters in the input string with their HTML equivalents. The purpose of this function is to serialize the input string into a format that can be safely rendered as HTML.
2. `serializeTextNode(text)`: This function creates a text node with the given text and then serializes it by getting the inner HTML of a parent element containing the text node.

**Html Preparation Code**

The html preparation code is empty, which means the benchmark doesn't prepare any additional HTML context for the tests.

**Test Cases**

There are three test cases:

1. `replaceAllWithShortcut("hello world")`: This test case uses the `replaceAllWithShortcut` function with a string that contains HTML tags ( `` and ``).
2. `serializeTextNode("hello world")`: This test case uses the `serializeTextNode` function with a string that contains HTML tags.
3. `replaceAllWithShortcut("hello world")`: This test case uses the `replaceAllWithShortcut` function without any HTML tags.

**Options Compared**

The benchmark compares three different approaches:

1. Using the `replaceAllWithShortcut` function with and without HTML tags (`"hello world"` vs. `"hello world"`).
2. Using the `serializeTextNode` function with a string containing HTML tags (`"hello world"`) compared to a plain string (`"hello world"`).

**Pros and Cons**

1. **Using `replaceAllWithShortcut` with HTML tags**:
	* Pros: May be faster since it only replaces special characters, which might be a bottleneck in some cases.
	* Cons: May not handle all edge cases correctly, such as Unicode characters or non-standard HTML entities.
2. **Using `serializeTextNode` with HTML tags**:
	* Pros: Correctly handles HTML tags and ensures the output is valid HTML.
	* Cons: Might be slower since it involves creating a text node and getting its inner HTML, which can involve additional overhead.
3. **Using `replaceAllWithShortcut` without HTML tags**:
	* Pros: Simplifies the function call and reduces overhead compared to using `serializeTextNode`.
	* Cons: May not handle all edge cases correctly, such as Unicode characters or non-standard HTML entities.

**Library**

The benchmark uses two libraries:

1. `String.prototype.replaceAll`: This is a built-in JavaScript method that replaces occurrences of a pattern in a string with another value.
2. `HTMLElement` and its child nodes: These are part of the DOM (Document Object Model) API, which provides a way to manipulate HTML documents programmatically.

**Special JS Features/Syntax**

The benchmark uses a few special features:

1. **Template literals**: The `replaceAllWithShortcut` function uses template literals (`''`) to create a new string with replaced characters.
2. **Arrow functions**: The `serializeTextNode` function is defined using an arrow function (`() => { ... }`), which provides a concise way to define small, anonymous functions.

Overall, the benchmark tests two different approaches to handling HTML tags in JavaScript strings: replacing special characters and serializing text nodes. The results will help determine which approach is faster and more efficient for specific use cases.

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
replaceAllWithShortcut	1668637.1 Ops/sec
serializeTextNode	2069582.5 Ops/sec
replaceAllWithShortcut no tags	11247157.0 Ops/sec

Related benchmarks:

html encode 3 (version: 0)

Comparing performance of: replaceAllWithShortcut vs serializeTextNode vs replaceAllWithShortcut no tags

Created: one month ago by: Guest

Jump to the latest result

replaceAllWithShortcut

serializeTextNode

replaceAllWithShortcut no tags

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):