Benchmark: JQuery new div element with class - 1k reps (with prototype.join)

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.js'></script>

Tests:

JQuery - direct + class
var list = [], n = 0; var newDiv = function(){ return $('<div class="test">'); } while(true) { n++; list.push(newDiv()); if(n===1000) break; }
JQuery - cloneNode + class
var list = [], n = 0, node = document.createElement('div'); var newDiv = function(){ var newNode = node.cloneNode(false); newNode.className = [].slice.call(arguments).join(' '); return $(node); } while(true) { n++; list.push(newDiv("test")); if(n===1000) break; }
prototype.join
var list = [], n = 0, node = document.createElement('div'); var newDiv = function (classname) { var newNode = node.cloneNode(false); if (classname !== void 0) newNode.className = Array.prototype.join.call(arguments, " "); return $(newNode); } while(true) { n++; list.push(newDiv("test")); if(n===1000) break; }
forcycle
var list = [], n = 0, node = document.createElement('div'); var newDiv = function (classname) { var newNode = node.cloneNode(false); if (classname !== void 0) { var args = new Array(arguments.length); for (var i = 0, ii = arguments.length; i < ii; i++) { args[i] = arguments[i]; } newNode.className = args.join(' '); } return $(newNode); } while(true) { n++; list.push(newDiv("test")); if(n===1000) break; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JQuery - direct + class
JQuery - cloneNode + class
prototype.join
forcycle

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 JavaScript microbenchmarks!

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents three test cases, each testing different approaches for creating new DOM elements with classes.

**Test Cases**

There are four test cases:

1. **JQuery - direct + class**: This test case creates a new DOM element using the jQuery ` $('<div class="test">')` method and sets its class attribute.
2. **JQuery - cloneNode + class**: This test case creates a new DOM element by cloning an existing element (`<div>`) and then sets its class attribute using the jQuery `$(node).addClass('test')` method.
3. **prototype.join**: This test case uses the `join()` method on the prototype chain of JavaScript arrays to concatenate a variable number of arguments into a string, which is then used as the class name for a new DOM element created by cloning an existing element (`<div>`) and wrapping it in jQuery.
4. **forcycle**: This test case uses a custom implementation called "forcycle" ( likely a typo or misname) to concatenate a variable number of arguments into a string, which is then used as the class name for a new DOM element created by cloning an existing element (`<div>`) and wrapping it in jQuery.

**Options Compared**

The test cases compare the performance of four different approaches:

1. Directly creating a new DOM element with a class attribute.
2. Using the `cloneNode()` method to create a new DOM element, followed by setting its class attribute using jQuery.
3. Using the `join()` method on the prototype chain of JavaScript arrays to concatenate a variable number of arguments into a string, which is then used as the class name for a new DOM element created by cloning an existing element.
4. A custom implementation called "forcycle" (likely a typo or misname) to concatenate a variable number of arguments into a string, which is then used as the class name for a new DOM element created by cloning an existing element.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **Direct + Class**: Pros: simple, fast; Cons: may require additional overhead due to the `class` attribute.
2. **CloneNode + Class**: Pros: can reuse DOM elements, reduces overhead; Cons: cloning an element can be slower than directly creating a new one.
3. **prototype.join**: Pros: uses built-in methods, potentially faster; Cons: may not work well for large numbers of arguments or complex class names.
4. **forcycle** (likely typo): Pros: potentially fast and efficient; Cons: unclear implementation details, may have performance issues due to excessive concatenation.

**Other Considerations**

* The use of jQuery in these test cases likely affects the results, as it introduces additional overhead and dependencies.
* The specific browser, device platform, and operating system used for testing may also impact the results.
* It's worth noting that the `join()` method on prototype chains is not a standard JavaScript feature and may not be supported by older browsers.

**Alternatives**

If you're interested in exploring alternative approaches, here are some options:

1. **Use a DOM library**: Libraries like React or Vue.js provide their own solutions for creating and manipulating DOM elements.
2. **Implement your own element creation function**: You could create a custom function that creates new DOM elements with classes, potentially optimized for performance.
3. **Use a build tool or compiler**: Some build tools like Webpack or Rollup can help optimize code for production environments.

Keep in mind that each approach has its trade-offs, and the best solution will depend on your specific use case and requirements.

Latest run results:

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

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

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
JQuery - direct + class	60.3 Ops/sec
JQuery - cloneNode + class	680.3 Ops/sec
prototype.join	613.1 Ops/sec
forcycle	669.7 Ops/sec

Related benchmarks:

JQuery new div element with class - 1k reps (with prototype.join) (version: 0)

Faster way to create new dom elements before insertion with JQuery (+ set class)

Comparing performance of: JQuery - direct + class vs JQuery - cloneNode + class vs prototype.join vs forcycle

Created: 9 months ago by: Guest

Jump to the latest result

JQuery - direct + class

JQuery - cloneNode + class

prototype.join

forcycle

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