Benchmark: Cherrypick replace child vs appending a document fragment

HTML Preparation code:

<div id='test-element'></div>

Script Preparation code:

var elements = [document.createElement('div'), document.createElement('div')];
var fragment = document.createDocumentFragment();
var container = document.getElementById('test-element');

elements.forEach(element => fragment.appendChild(element));
container.appendChild(fragment);

Tests:

Cherrypick append child
var changeIndex = 1; elements[changeIndex] = document.createElement('div'); container.replaceChild(elements[changeIndex], container.children[changeIndex]);
Using documentFragment, append new & reuse old children
var changeIndex = 1; var newChildren = document.createDocumentFragment(); elements[changeIndex] = document.createElement('div'); elements.forEach(element => newChildren.appendChild(element)); while(container.firstChild) { container.firstChild.remove(); } container.appendChild(newChildren)
replaceChildren method
var changeIndex = 1; elements[changeIndex] = document.createElement('div'); container.replaceChildren(elements)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Cherrypick append child
Using documentFragment, append new & reuse old children
replaceChildren method

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15

Browser/OS: Safari 17 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Cherrypick append child	765693.4 Ops/sec
Using documentFragment, append new & reuse old children	400501.4 Ops/sec
replaceChildren method	813957.1 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.

**Benchmark Overview**

The benchmark compares three different approaches to replace or append child nodes to an HTML element:

1. `replaceChild` (Method 1)
2. Using a `documentFragment` to append new children while reusing old ones (Method 2)
3. Replacing all child nodes using the `replaceChildren` method (Method 3)

**Options Compared**

The benchmark compares three approaches:

* **Method 1: replaceChild**
	+ Replaces only the specified child node.
	+ Pros: Simple, efficient for small sets of children.
	+ Cons: May lead to unnecessary DOM mutations if not used carefully.
* **Method 2: Using documentFragment**
	+ Creates a fragment that can be appended to the container, reusing old nodes and adding new ones efficiently.
	+ Pros: Can be more efficient than `replaceChild` for larger sets of children, reduces unnecessary DOM mutations.
	+ Cons: May require additional memory allocation, more complex setup.
* **Method 3: replaceChildren**
	+ Replaces all child nodes at once.
	+ Pros: Simple and easy to use, reduces the number of DOM mutations compared to `replaceChild`.
	+ Cons: Can be less efficient than Method 2 for large sets of children, may lead to unnecessary node creation.

**Library Usage**

None of the benchmark methods explicitly use any libraries. However, they do rely on the browser's built-in DOM APIs.

**Special JS Features or Syntax**

No special JavaScript features or syntax are used in this benchmark. It only relies on standard DOM APIs and variable declarations.

**Other Alternatives**

Other approaches to replacing or appending child nodes could be considered:

* Using `appendChild` repeatedly (inefficient, as it creates a new parent node each time).
* Using a loop to iterate over the children array and append/remove nodes individually (less efficient than Method 2, which reuses old nodes).
* Using a library like jQuery that provides an optimized way to manipulate DOM elements.

Keep in mind that these alternatives may not be more efficient or practical for real-world scenarios, and the benchmark is primarily designed to compare the performance of these three specific methods.

Related benchmarks:

Cherrypick replace child vs appending a document fragment (version: 0)

Comparing performance of: Cherrypick append child vs Using documentFragment, append new & reuse old children vs replaceChildren method

Created: 4 years ago by: Guest

Jump to the latest result

Cherrypick append child

Using documentFragment, append new & reuse old children

replaceChildren method

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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