Benchmark: Getting a context: closest vs while loop vs event propagation with new events vs event propagation with callbacks

HTML Preparation code:

<context-provider id="provider">
  <div>
    <div></div>
    <div>
      <span>
        <span>
          <span>abc</span>
        </span>
        def
        <span>
          <span id="foo"></span>
        </span>
      </span>
      ghi
    </div>
  </div>
</context-provider>

Script Preparation code:

var context = document.getElementById('provider');
var element = document.getElementById('foo');

var SimpleContextEvent = class SimpleContextEvent extends Event {
  data = null;
  callback = null;
  
  constructor(callback) {
    super('context-request', {bubbles: true, composed: true});
    this.callback = callback;
  }
};

context.addEventListener('context-request', event => {
  if (event.callback) {
    event.callback(context); 
  } else {
    event.data = context;
  }
  
  event.stopPropagation();
});

Tests:

closest with element selector
var i = 5000; while (i--) { let ctx = element; ctx = ctx.closest('context-provider'); if (ctx !== context) { throw new Error('mismatch'); } }
while loop + tagName check
var i = 5000; while (i--) { let ctx = element; while (ctx) { if (ctx.tagName === 'CONTEXT-PROVIDER') { break; } ctx = ctx.parentNode; } if (ctx !== context) { throw new Error('mismatch'); } }
event propagation
var i = 5000; while (i--) { let ctxEvent = new SimpleContextEvent(); element.dispatchEvent(ctxEvent); let ctx = ctxEvent.data; if (ctx !== context) { throw new Error('mismatch'); } }
event propagation with callback
var i = 5000; var ctx; var ctxEvent = new SimpleContextEvent(reply => {ctx = reply;}); while (i--) { ctx = null; element.dispatchEvent(ctxEvent); if (ctx !== context) { throw new Error('mismatch'); } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
closest with element selector
while loop + tagName check
event propagation
event propagation with callback

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 dive into the world of microbenchmarks.

**Benchmark Overview**

The provided JSON represents a JavaScript benchmarking test case, which measures the performance of different approaches to get a contextual element (in this case, an element with the `context-provider` class) using various methods. The test is designed to compare the speed and efficiency of these approaches across multiple browsers and devices.

**Test Cases**

There are four individual test cases:

1. **"closest with element selector"**: This test case uses the `closest()` method on the `element` variable to find the nearest ancestor with the `context-provider` class. It then checks if this element is equal to the expected `context` value.
2. **"while loop + tagName check"**: In this test, a while loop is used to iterate through the DOM tree from the `element` down, checking each parent node's tag name until it finds one with the `context-provider` class. If the final result does not match the expected `context`, an error is thrown.
3. **"event propagation"**: This test case dispatches a custom event (`SimpleContextEvent`) on the `element` and checks if the resulting data matches the expected `context` value after stopping event propagation with `event.stopPropagation()`.
4. **"event propagation with callback"**: Similar to the previous test, but instead of using a simple event handler, it uses a callback function (via the `SimpleContextEvent` constructor) to handle the dispatched event.

**Library and Special JS Features**

The custom library used here is called `SimpleContextEvent`, which extends the built-in `Event` class. It provides additional functionality for creating events with custom data and callbacks. The `context-provider` element is not a standard HTML element, but rather a custom class applied to an element.

**Options Compared**

Here's a brief summary of each test case:

* **Test Case 1**: Uses the built-in `closest()` method, which is likely to be the fastest approach due to its optimized implementation.
* **Test Case 2**: Employs a while loop with tagName checks, which may introduce unnecessary overhead but is still efficient in this specific use case.
* **Test Case 3**: Utilizes event propagation, which can lead to slower performance as it traverses the DOM tree. However, some browsers (like Chrome) are optimized for event propagation and might perform well here.
* **Test Case 4**: Combines event dispatching with a callback function, similar to Test Case 3, but adds an additional layer of overhead due to the asynchronous nature of callbacks.

**Pros and Cons**

Here's a brief pros-and-cons summary for each test case:

* **Test Case 1 (closest())**: Pros: Fastest approach; Cons: May not work in older browsers or with complex DOM structures.
* **Test Case 2 (while loop + tagName check)**: Pros: Efficient, especially for small to medium-sized DOM trees; Cons: Might be slower due to unnecessary checks.
* **Test Case 3 (event propagation)**: Pros: Optimized for event propagation; Cons: May introduce unnecessary overhead and slow down performance in some cases.
* **Test Case 4 (event propagation with callback)**: Pros: Asynchronous handling, potentially beneficial in certain scenarios; Cons: Adds additional overhead due to callbacks.

**Other Alternatives**

Some alternative approaches that might be worth considering:

* Using a library like `jQuery` or `React` for event handling and DOM manipulation.
* Employing CSS selectors (e.g., `context-provider`) for faster element selection.
* Utilizing modern browser features, such as `getElementsByClassName()` or `querySelectorAll()`, which are optimized for performance.

Keep in mind that the choice of approach depends on your specific use case, target browsers, and requirements. These microbenchmarks should provide a general idea of each method's relative performance but might not be representative of all scenarios.

Latest run results:

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

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

Browser/OS: Chrome 122 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
closest with element selector	1560.4 Ops/sec
while loop + tagName check	958.6 Ops/sec
event propagation	209.8 Ops/sec
event propagation with callback	305.2 Ops/sec

Related benchmarks:

Getting a context: closest vs while loop vs event propagation with new events vs event propagation with callbacks (version: 0)

Comparing performance of: closest with element selector vs while loop + tagName check vs event propagation vs event propagation with callback

Created: one year ago by: Guest

Jump to the latest result

closest with element selector

while loop + tagName check

event propagation

event propagation with callback

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):