Benchmark: Creating elements with cloneNode (template vs. normal element)

Script Preparation code:

var simpleTemplate = document.createElement("template");
simpleTemplate.innerHTML = `<span class="simple"></span>`;
  
var complexTemplate = document.createElement("template");
complexTemplate.innerHTML =
  `<span class="complex">
     <span class="simple-1"></span>
     <span class="simple-2">
       <span class="simple-2-1"></span>
     </span>
     <span class="simple-3">
       <span class="simple-3-1"></span>
     </span>
     <span class="simple-4"></span>
   </span>`;

var simpleElement = document.createElement("span");
simpleElement.classList.add("simple");
  
var complexElement = document.createElement("span");
complexElement.classList.add("complex");
complexElement.innerHTML =
  `<span class="simple-1"></span>
   <span class="simple-2">
     <span class="simple-2-1"></span>
   </span>
   <span class="simple-3">
     <span class="simple-3-1"></span>
   </span>
   <span class="simple-4"></span>`;

Tests:

Simple - Template
let el = document.createElement("div"); let content = simpleTemplate.content.cloneNode(true); el.appendChild(content);
Simple - JavaScript
let el = document.createElement("div"); let content = simpleElement.cloneNode(true); el.appendChild(content);
Complex - Template
let el = document.createElement("div"); let content = complexTemplate.content.cloneNode(true); el.appendChild(content);
Complex - JavaScript
let el = document.createElement("div"); let content = complexElement.cloneNode(true); el.appendChild(content);

Historical Performance Data aggregated from 11 community runs

Desktop Results:

Chrome 11 runs

Simple - JavaScript

1.1M/s

Simple - Template

799K/s

Complex - JavaScript

308K/s

Complex - Template

284K/s

Fastest: Simple - JavaScript (4.0x faster)

View exact numbers

✓ Simple - JavaScript: 1,146,987 ops/sec
• Simple - Template: 798,956 ops/sec
• Complex - JavaScript: 308,056 ops/sec
• Complex - Template: 283,989 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Simple - Template
Simple - JavaScript
Complex - Template
Complex - JavaScript

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 7 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36

Browser/OS: Chrome 143 on Mac OS X 10.15.7

View result in a separate tab

Simple - JavaScript

2.6M/s

Simple - Template

1.8M/s

Complex - Template

418K/s

Complex - JavaScript

262K/s

View exact numbers

Test name	Executions per second
✓ Simple - JavaScript	2,576,029 Ops/sec
Simple - Template	1,753,264 Ops/sec
Complex - Template	418,206 Ops/sec
Complex - JavaScript	262,475 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The benchmark measures the performance of two approaches to create elements: using HTML templates (`template`) versus creating elements directly in JavaScript (`normal element`).

There are four individual test cases:

1. **Simple - Template**: Creates a `div` element from an HTML template.
2. **Simple - JavaScript**: Creates a `div` element by cloning a normal JavaScript element.
3. **Complex - Template**: Creates a more complex `div` element from an HTML template.
4. **Complex - JavaScript**: Creates a more complex `div` element by cloning a normal JavaScript element.

**Template Approach**

Using HTML templates allows for faster creation of elements, as it bypasses the DOM manipulation and serialization steps. This approach is particularly useful when creating complex structures with nested elements.

Pros:

* Faster execution times due to reduced DOM manipulation.
* Better performance when creating complex structures.

Cons:

* Requires additional setup (creating a `template` element) and parsing the HTML template string.
* Limited flexibility in modifying or updating the template content.

**JavaScript Approach**

Cloning a normal JavaScript element involves serializing its contents, which can lead to slower execution times compared to using templates.

Pros:

* More flexible than templates, as it allows for easy modification of the cloned element's content.
* No additional setup required, as existing elements can be cloned directly.

Cons:

* Slower execution times due to DOM manipulation and serialization.
* May not perform well when creating complex structures with nested elements.

**Other Considerations**

The benchmark also considers factors such as browser version (Chrome 126) and platform (Desktop), which may affect the performance results. Additionally, the test cases are executed at different frequencies per second (`ExecutionsPerSecond` values).

**Library/Functionality Overview**

In this benchmark, two libraries/functionalities are used:

1. `cloneNode(true)`: This method creates a deep clone of an element and its contents.
2. `innerHTML` and `classList.add()`: These properties allow for setting the inner HTML and adding classes to elements.

**Special JS Feature/Syntax**

There is no special JavaScript feature or syntax used in this benchmark, apart from using the `cloneNode(true)` method, which is a standard DOM API function.

**Alternatives**

If you're interested in exploring alternative approaches, consider:

1. **Document Fragment**: Creating document fragments can be another efficient way to create complex structures without relying on templates.
2. **Canvas or SVG**: Using canvas or SVG elements for rendering graphics can provide an alternative performance path compared to DOM manipulation.
3. **JavaScript libraries like React or Angular**: These frameworks provide their own optimized solutions for building and manipulating complex UI components, which may offer better performance than the benchmark's approaches.

Keep in mind that this benchmark is designed to measure specific performance aspects of creating elements using templates versus JavaScript cloning, so exploring alternative approaches might require adapting the benchmarking setup and scenarios.

Creating elements with cloneNode (template vs. normal element) (version: 0)

Comparing performance of: `Simple - Template vs Simple - JavaScript vs Complex - Template vs Complex - JavaScript`

Created: 5 years ago by: Guest

Go to the latest result

Simple - Template

Simple - JavaScript

Complex - Template

Complex - JavaScript

Historical Performance Data aggregated from 11 community runs

Desktop Results:

Chrome 11 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Creating elements with cloneNode (template vs. normal element) (version: 0)

Comparing performance of: Simple - Template vs Simple - JavaScript vs Complex - Template vs Complex - JavaScript

Created: 5 years ago by: Guest

Go to the latest result

Simple - Template

Simple - JavaScript

Complex - Template

Complex - JavaScript

Historical Performance Data aggregated from 11 community runs

Desktop Results:

Chrome 11 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `Simple - Template vs Simple - JavaScript vs Complex - Template vs Complex - JavaScript`