Benchmark: Classnames vs CLSX vs Alternatives vs Keys

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/classnames/2.2.6/index.min.js'></script>
<script src='https://unpkg.com/clsx@1.1.0/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`
Keys, filter, map, join
let objStyle = Object.keys(obj).filter((p)=>obj[p]).join(' '); let result = `${str} ${objStyle} ${objStyle} test classname`

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
Keys, filter, map, join

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The MeasureThat.net benchmark tests the performance of three different approaches to create a template string in JavaScript:

1. `classnames` and `clsx`: Two libraries that provide an easy way to concatenate class names with other strings.
2. Custom implementations: Three custom functions that use different techniques to build the template string.

**Libraries**

1. **Classnames**: A lightweight library (2.2.6) that allows you to create a template string by concatenating class names with other strings using the `classNames` function.
2. **CLSX**: Another lightweight library (similar version to Classnames) that provides an easy way to concatenate class names with other strings using the `clsx` function.

**Custom Implementations**

1. **Return Structured String**: This implementation uses a template string syntax similar to the built-in JavaScript `template literals`, but without the interpolation feature.
2. **Entries, Filter, Map, Join**: This approach uses the `Object.entries()` method to iterate over an object's key-value pairs, filters out values that are not truthy, maps each key to its corresponding value using `map()`, and joins the resulting array of keys into a string using `join()`.
3. **Keys, Filter, Map, Join**: Similar to the previous implementation, but uses `Object.keys()` instead of `Object.entries()`.

**Performance Comparison**

The latest benchmark results show that:

* The custom implementations have the best performance, with:
	+ Return Structured String: 118.03 ms (per 1668974 executions)
	+ Entries, Filter, Map, Join: 132.85 ms (per 1668974 executions)
* CLSX has a good performance, with: 140.83 ms (per 1668974 executions)
* Classnames is the slowest, with: 216.35 ms (per 1668974 executions)

**Key Takeaways**

1. Custom implementations are generally faster than using libraries.
2. The `Entries, Filter, Map, Join` approach and the `Keys, Filter, Map, Join` approach have similar performance characteristics.
3. CLSX is a good alternative to Classnames in terms of performance.

Overall, the benchmark suggests that custom implementations can be a better choice when building template strings in JavaScript, especially if you need fine-grained control over the concatenation process.

Latest run results:

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

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

Browser/OS: Chrome 86 on Windows

View result in a separate tab

Test name	Executions per second
classnames	1075789.2 Ops/sec
clsx	1471799.2 Ops/sec
Array based	1180271.4 Ops/sec
String based (return struct)	1645721.2 Ops/sec
String based (if-else struct)	1668974.9 Ops/sec
Entries, filter, map, join	1413105.2 Ops/sec
Keys, filter, map, join	1354008.5 Ops/sec

Related benchmarks:

Classnames vs CLSX vs Alternatives vs Keys (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 Keys, filter, map, join

Created: 4 years 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

Keys, filter, map, join

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