Benchmark: Classnames vs CLSX vs Alternatives vs custom

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/classnames/2.3.2/index.min.js'></script>
<script src='https://unpkg.com/clsx@1.2.1/dist/clsx.min.js'></script>

Script Preparation code:

var str = 'style';
var obj = {
 	 'style-2': true,
  	 'style-3': false,
 	 'style-4': true,
}
var arr = ['style-5', 'style-6']

Tests:

classnames
let result = window.classNames(str, obj, arr, 'test classname')
clsx
let result = window.clsx(str, obj, arr, 'test classname')
Array based
function ts(...args){ let template = []; args.forEach(arg => { if (typeof arg === 'string') { template.push(arg); return; } if (arg.join) { template = [...template, ...arg]; return; } let entries = Object.entries(arg); if (entries.length) { entries.forEach(entry => { if(entry[1]) template.push(entry[0]) }) } }) return template.join(' '); } let result = ts(str, obj, arr, 'test classname')
String based (return struct)
function ts(...args){ let template = ''; args.forEach(arg => { if (typeof arg === 'string') { template += ' '+arg; return; } if (arg.join) { arg.forEach((e) => { template += ' ' + e; }) return; } let entries = Object.entries(arg); if (entries.length) { entries.forEach(entry => { if(entry[1]) template += ' ' + entry[0] }) } }) return template; } let result = ts(str, obj, arr, 'test classname')
String based (if-else struct)
function ts(...args){ let template = ''; args.forEach(arg => { if (typeof arg === 'string') { template += ' '+arg; } else if (arg.join) { arg.forEach((e) => { template += ' ' + e; }) } else { let entries = Object.entries(arg); if (entries.length) { entries.forEach(entry => { if(entry[1]) template += ' ' + entry[0] }) } } }) return template; } let result = ts(str, obj, arr, 'test classname')
Entries, filter, map, join
let objStyle = Object.entries(obj).filter((style)=>style[1]).map(style => style[0]).join(' '); let arrComb = arr.join(' ') let result = `${str} ${objStyle} ${arrComb} test classname`
Flat array join
const cn = (...classnames) => classnames.flat().filter(Boolean).join(" "); let result = cn('style', true, false, null, 'style-4', ['style-5', 'style-6'])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
classnames
clsx
Array based
String based (return struct)
String based (if-else struct)
Entries, filter, map, join
Flat array join

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
classnames	2927829.5 Ops/sec
clsx	4222923.0 Ops/sec
Array based	3022913.2 Ops/sec
String based (return struct)	3941093.8 Ops/sec
String based (if-else struct)	3930229.8 Ops/sec
Entries, filter, map, join	3509382.8 Ops/sec
Flat array join	2882309.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to explain the benchmark and the different approaches tested.

**Benchmark Overview**

The benchmark is designed to compare the performance of four different approaches for creating a template string from an object with string values and an array of strings.

**Approaches Compared**

1. **classnames**: A library function that takes an array of strings and returns a single string with the class names joined together.
2. **String based (return struct)**: A simple approach where the template string is built by concatenating the string values from the object and the array, using the `join()` method to concatenate the individual parts.
3. **String based (if-else struct)**: Similar to the previous approach, but uses an if-else statement to filter out the boolean values from the object before joining them with the string values.
4. **Entries, filter, map, join**: A more complex approach that involves filtering out the non-string values from the object, mapping over the remaining strings to extract their values, and then joining them together.

**How it Works**

The benchmark script generates a template string by concatenating several parts:

* The `str` variable (e.g., "style")
* The filtered and mapped string values from the object
* The joined array of strings

Each approach has its own implementation for building this template string. The benchmark measures the time taken to execute each approach and reports the results.

**Interpretation of Results**

The latest benchmark result shows that:

* **clsx**: The library function `classnames` performs best, with an average of 4222923 executions per second.
* **String based (return struct)**: This simple approach is slower than `clsx`, but still faster than the more complex approaches. Average execution speed: 3941093.75 executions per second.
* **String based (if-else struct)**: This approach is slightly slower than the previous one, with an average execution speed of 3930229.75 executions per second.
* **Entries, filter, map, join**: The most complex approach is the slowest, with an average execution speed of 3509382.75 executions per second.
* **Array based**: This approach is slower than `clsx` but faster than the string-based approaches. Average execution speed: 2927829.5 executions per second.

**Conclusion**

The benchmark results suggest that `classnames` is the fastest approach for creating a template string from an object with string values and an array of strings. The simple string-based approach (`String based (return struct)`) is still faster than the more complex approaches, which may be due to the overhead of filtering, mapping, and joining operations.

Related benchmarks:

Classnames vs CLSX vs Alternatives vs custom (version: 0)

Compare CLSX vs Classnames vs an own implementation of creating a template string

Comparing performance of: classnames vs clsx vs Array based vs String based (return struct) vs String based (if-else struct) vs Entries, filter, map, join vs Flat array join

Created: one year ago by: Guest

Jump to the latest result

classnames

clsx

Array based

String based (return struct)

String based (if-else struct)

Entries, filter, map, join

Flat array join

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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